public static PNStatusCategory GetPNStatusCategory(WebExceptionStatus webExceptionStatus, string webExceptionMessage) { PNStatusCategory ret = PNStatusCategory.PNUnknownCategory; switch (webExceptionStatus) { case WebExceptionStatus.RequestCanceled: ret = PNStatusCategory.PNCancelledCategory; break; case WebExceptionStatus.ConnectFailure: case WebExceptionStatus.SendFailure: case WebExceptionStatus.Pending: case WebExceptionStatus.Success: ret = PNStatusCategory.PNNetworkIssuesCategory; break; default: if (string.Compare(webExceptionStatus.ToString(), "SecureChannelFailure", StringComparison.CurrentCultureIgnoreCase) == 0 || string.Compare(webExceptionStatus.ToString(), "NameResolutionFailure", StringComparison.CurrentCultureIgnoreCase) == 0) { ret = PNStatusCategory.PNNetworkIssuesCategory; } else { Debug.WriteLine("ATTENTION: webExceptionStatus = " + webExceptionStatus.ToString()); } break; } return(ret); }
public static PNStatus CreatePNStatus(PNStatusCategory category, string errorString, Exception errorException, bool error, PNOperationType operation, ChannelEntity channelEntity, RequestState pnRequestState, PubNubUnity pnUnity) { PNErrorData errorData = null; if ((!string.IsNullOrEmpty(errorString)) || (errorException != null)) { errorData = new PNErrorData(); errorData.Info = errorString; errorData.Ex = errorException; } List <string> affectedChannels = null; List <string> affectedChannelGroups = null; if (channelEntity.ChannelID.IsChannelGroup) { affectedChannelGroups = new List <string>(); affectedChannelGroups.Add(channelEntity.ChannelID.ChannelOrChannelGroupName); } else { affectedChannels = new List <string>(); affectedChannels.Add(channelEntity.ChannelID.ChannelOrChannelGroupName); } return(CreatePNStatus(category, errorData, error, operation, affectedChannels, affectedChannelGroups, pnRequestState, pnUnity)); }
private void RaiseConnectionStatusResponse(bool isError, PNStatusCategory category, Action <ConnectionStatusEventData> callback, Exception exception = null) { connectionStatusEventData = new ConnectionStatusEventData(EventSystem.current); connectionStatusEventData.Initialize(isError, category, exception); callback(connectionStatusEventData); }
public static PNStatus CreatePNStatus(PNStatusCategory category, string errorString, Exception errorException, bool error, PNOperationType operation, List <ChannelEntity> affectedChannels, List <ChannelEntity> affectedChannelGroups, RequestState pnRequestState, PubNubUnity pnUnity) { PNErrorData errorData = CreateErrorData(errorString, errorException); List <string> channels = CreateListOfStringFromListOfChannelEntity(affectedChannels); List <string> channelGroups = CreateListOfStringFromListOfChannelEntity(affectedChannelGroups); return(CreatePNStatus(category, errorData, error, operation, channels, channelGroups, pnRequestState, pnUnity)); }
internal static PNStatus CreatePNStatus(PNStatusCategory category, PNErrorData errorData, bool error, PNOperationType operation, List <string> channels, List <string> channelGroups, RequestState pnRequestState, PubNubUnity pnUnity) { long statusCode = 0; string url = ""; if (pnRequestState != null) { statusCode = pnRequestState.ResponseCode; url = pnRequestState.URL; } PNStatus pnStatus = new PNStatus( category, errorData, error, statusCode, operation, pnUnity.PNConfig.Secure, pnUnity.PNConfig.UUID, pnUnity.PNConfig.AuthKey, pnUnity.PNConfig.Origin, channels, channelGroups, url ); #if (ENABLE_PUBNUB_LOGGING) pnUnity.PNLog.WriteToLog(string.Format("CreatePNStatus: \n" + "category={0} \n" + "errorData={1} \n" + "error={2} \n" + "statusCode={3} \n" + "operation={4} \n" + "tlsEnabled={5} \n" + "uuid={6} \n" + "authKey={7} \n" + "origin={8} \n" + "channels={9} \n" + "channelGroups={10} \n" + "clientRequest={11} \n", category.ToString(), ((errorData != null) && (errorData.Ex != null)) ? errorData.Ex.ToString() : "null", error.ToString(), statusCode.ToString(), operation.ToString(), pnUnity.PNConfig.Secure, pnUnity.PNConfig.UUID, pnUnity.PNConfig.AuthKey, pnUnity.PNConfig.Origin, (channels != null) ? string.Join(",", channels.ToArray()) : "null", (channelGroups != null) ? string.Join(",", channelGroups.ToArray()) : "null", url ), PNLoggingMethod.LevelInfo); #endif return(pnStatus); }
private void RaiseConnectionStatusResponse(bool isError, PNStatusCategory category, Action<ConnectionStatusEventData> callback, Exception exception = null) { Debug.Log(displayName + "1"); connectionStatusEventData = new ConnectionStatusEventData(EventSystem.current); Debug.Log(displayName + "2"); connectionStatusEventData.Initialize(isError, category, exception); Debug.Log(displayName + "3"); //callback(connectionStatusEventData); }
private void PubnubStatusCategoryLogger(PNStatusCategory category) { bool isError = false; switch (category) { case PNStatusCategory.PNNetworkIssuesCategory: break; case PNStatusCategory.PNReconnectedCategory: break; case PNStatusCategory.PNConnectedCategory: PubnubCatchUp(); break; case PNStatusCategory.PNAccessDeniedCategory: break; case PNStatusCategory.PNAcknowledgmentCategory: break; case PNStatusCategory.PNTimeoutCategory: break; case PNStatusCategory.PNDisconnectedCategory: break; case PNStatusCategory.PNUnexpectedDisconnectCategory: break; case PNStatusCategory.PNBadRequestCategory: break; case PNStatusCategory.PNMalformedFilterExpressionCategory: break; case PNStatusCategory.PNMalformedResponseCategory: break; case PNStatusCategory.PNDecryptionErrorCategory: break; case PNStatusCategory.PNTLSConnectionFailedCategory: break; case PNStatusCategory.PNRequestMessageCountExceededCategory: break; } RaiseConnectionStatusResponse(isError, category, handleConnectionStatusCallback); }
private static void ParseCheckSocketConnectException <T>(Exception ex, PNOperationType type, PNCallback <T> callback, Action <bool> internalcallback) { PNStatusCategory errorCategory = PNStatusCategoryHelper.GetPNStatusCategory(ex); StatusBuilder statusBuilder = new StatusBuilder(pubnubConfig, jsonLib); PNStatus status = statusBuilder.CreateStatusResponse <T>(type, errorCategory, null, (int)System.Net.HttpStatusCode.NotFound, new PNException(ex)); if (callback != null) { callback.OnResponse(default(T), status); } LoggingMethod.WriteToLog(pubnubLog, string.Format("DateTime {0} ParseCheckSocketConnectException Error. {1}", DateTime.Now.ToString(CultureInfo.InvariantCulture), ex.Message), pubnubConfig.LogVerbosity); internalcallback(false); }
private void RaiseConnectionStatusResponse(bool isError, PNStatusCategory category, Action <ConnectionStatusEventData> callback, Exception exception = null) { connectionStatusEventData = new ConnectionStatusEventData(EventSystem.current); connectionStatusEventData.Initialize(isError, category, exception); if (callback == null) { log("connectionStatusCallback not implemented!"); } else { callback(connectionStatusEventData); } }
public PNStatus(PNStatusCategory category, PNErrorData errorData, bool error, long statusCode, PNOperationType operation, bool tlsEnabled, string uuid, string authKey, string origin, List <String> affectedChannels, List <String> affectedChannelGroups, object clientRequest) { this.Category = category; this.ErrorData = errorData; this.Error = error; this.StatusCode = statusCode; this.Operation = operation; this.TlsEnabled = tlsEnabled; this.UUID = uuid; this.AuthKey = authKey; this.Origin = origin; this.ClientRequest = clientRequest; this.AffectedChannelGroups = affectedChannelGroups; this.AffectedChannels = affectedChannels; }
protected void CreateErrorResponse(PNStatusCategory pnStatusCategory, Exception exception, bool showInCallback, RequestState pnRequestState) { PNStatus pnStatus = Helpers.CreatePNStatus( pnStatusCategory, exception.Message, exception, true, OperationType, ChannelsToUse, ChannelGroupsToUse, pnRequestState, PubNubInstance ); if (showInCallback) { Callback(null, pnStatus); } }
protected void OnPubnubWebRequestTimeout <T>(System.Object requestState) { RequestState <T> currentState = requestState as RequestState <T>; if (currentState != null && currentState.Response == null && currentState.Request != null) { currentState.Timeout = true; try { currentState.Request.Abort(); } catch { /* ignore */ } LoggingMethod.WriteToLog(pubnubLog, string.Format("DateTime: {0}, **WP7 OnPubnubWebRequestTimeout**", DateTime.Now.ToString(CultureInfo.InvariantCulture)), pubnubConfig.LogVerbosity); if (currentState.ResponseType != PNOperationType.PNSubscribeOperation && currentState.ResponseType != PNOperationType.Presence && currentState.ResponseType != PNOperationType.PNHeartbeatOperation && currentState.ResponseType != PNOperationType.Leave) { PNStatusCategory errorCategory = PNStatusCategory.PNTimeoutCategory; PNStatus status = new StatusBuilder(pubnubConfig, jsonLib).CreateStatusResponse <T>(currentState.ResponseType, errorCategory, currentState, (int)HttpStatusCode.NotFound, new PNException("Request timeout")); if (currentState.Channels != null && currentState.Channels.Length > 0) { status.AffectedChannels.AddRange(currentState.Channels); } if (currentState.ChannelGroups != null && currentState.ChannelGroups.Length > 0) { status.AffectedChannels.AddRange(currentState.ChannelGroups); } if (currentState.PubnubCallback != null) { currentState.PubnubCallback.OnResponse(default(T), status); } } } }
public static PNStatusCategory GetPNStatusCategory(Exception ex) { PNStatusCategory ret = PNStatusCategory.PNUnknownCategory; if (ex == null) { return(ret); } string errorType = ex.GetType().ToString(); string errorMessage = ex.Message; if (errorType == "System.FormatException" && errorMessage == "Invalid length for a Base-64 char array or string.") { ret = PNStatusCategory.PNDecryptionErrorCategory; } else if (errorType == "System.FormatException" && errorMessage == "The input is not a valid Base-64 string as it contains a non-base 64 character, more than two padding characters, or an illegal character among the padding characters. ") { ret = PNStatusCategory.PNDecryptionErrorCategory; } else if (errorType == "System.ObjectDisposedException" && errorMessage == "Cannot access a disposed object.") { ret = PNStatusCategory.PNUnknownCategory; } else if (errorType == "System.Net.Sockets.SocketException" && errorMessage == "The requested name is valid, but no data of the requested type was found") { ret = PNStatusCategory.PNNetworkIssuesCategory; } else if (errorType == "System.Net.Sockets.SocketException" && errorMessage == "No such host is known") { ret = PNStatusCategory.PNNetworkIssuesCategory; } else if (errorType == "System.Security.Cryptography.CryptographicException" && errorMessage == "Padding is invalid and cannot be removed.") { ret = PNStatusCategory.PNDecryptionErrorCategory; } else if (errorType == "System.Runtime.InteropServices.SEHException" && errorMessage == "External component has thrown an exception.") { ret = PNStatusCategory.PNUnknownCategory; } else if (errorType == "System.Net.WebException" && errorMessage.Contains("The remote name could not be resolved:")) { ret = PNStatusCategory.PNNetworkIssuesCategory; } else if (errorType == "System.Net.WebException" && errorMessage.Contains("Unable to connect to the remote server")) { ret = PNStatusCategory.PNNetworkIssuesCategory; } else if (errorType == "System.Net.WebException" && errorMessage.Contains("Unable to read data from the transport connection")) { ret = PNStatusCategory.PNNetworkIssuesCategory; } else if (errorType == "System.Net.WebException" && errorMessage.Contains("SecureChannelFailure")) { ret = PNStatusCategory.PNNetworkIssuesCategory; } else if (errorType == "System.Net.WebException" && errorMessage.Contains("ConnectFailure")) { ret = PNStatusCategory.PNNetworkIssuesCategory; } else if (errorType == "System.Net.WebException" && errorMessage.Contains("ReceiveFailure")) { ret = PNStatusCategory.PNNetworkIssuesCategory; } else if (errorType == "System.Net.WebException" && errorMessage.Contains("SendFailure")) { ret = PNStatusCategory.PNNetworkIssuesCategory; } else if (errorType == "System.ArgumentException" && errorMessage.Contains("cannot be converted to type")) { ret = PNStatusCategory.PNMalformedResponseCategory; } else if (errorMessage.Contains("Disconnected")) { ret = PNStatusCategory.PNDisconnectedCategory; } return(ret); }
public static PNStatusCategory GetPNStatusCategory(int statusCode, string httpErrorCodeMessage) { PNStatusCategory ret = PNStatusCategory.PNUnknownCategory; switch (statusCode) { case 400: if (httpErrorCodeMessage.ToUpperInvariant().Contains("MESSAGE TOO LARGE")) { ret = PNStatusCategory.PNBadRequestCategory; } else if (httpErrorCodeMessage.ToUpperInvariant() == "INVALID KEY" || httpErrorCodeMessage.ToUpperInvariant() == "INVALID SUBSCRIBE KEY") { ret = PNStatusCategory.PNAccessDeniedCategory; } else if (httpErrorCodeMessage.ToUpperInvariant() == "BADREQUEST") { ret = PNStatusCategory.PNBadRequestCategory; } else if (httpErrorCodeMessage.ToUpperInvariant() == "NO UUID SPECIFIED") { ret = PNStatusCategory.PNBadRequestCategory; } else if (httpErrorCodeMessage.ToUpperInvariant() == "INVALID TIMESTAMP") { ret = PNStatusCategory.PNBadRequestCategory; } else if (httpErrorCodeMessage.ToUpperInvariant() == "INVALID TYPE ARGUMENT") { ret = PNStatusCategory.PNBadRequestCategory; } else if (httpErrorCodeMessage.ToUpperInvariant() == "CHANNEL GROUP OR GROUPS RESULT IN EMPTY SUBSCRIPTION SET") { ret = PNStatusCategory.PNBadRequestCategory; } else if (httpErrorCodeMessage.ToUpperInvariant() == "COULD NOT PARSE REQUEST") { ret = PNStatusCategory.PNBadRequestCategory; } break; case 401: ret = PNStatusCategory.PNAccessDeniedCategory; break; case 402: if (httpErrorCodeMessage.ToUpperInvariant() == "NOT ENABLED") { ret = PNStatusCategory.PNAccessDeniedCategory; } break; case 403: if (httpErrorCodeMessage.ToUpperInvariant() == "FORBIDDEN") { ret = PNStatusCategory.PNAccessDeniedCategory; } else if (httpErrorCodeMessage.ToUpperInvariant() == "SIGNATURE DOES NOT MATCH") { ret = PNStatusCategory.PNAccessDeniedCategory; } break; case 404: case 414: case 500: ret = PNStatusCategory.PNBadRequestCategory; break; case 502: case 503: case 504: ret = PNStatusCategory.PNNetworkIssuesCategory; break; default: ret = PNStatusCategory.PNUnknownCategory; break; } return(ret); }
private async Task <PNResult <PNPublishResult> > Signal(string channel, object message, Dictionary <string, object> metaData, Dictionary <string, object> externalQueryParam) { PNResult <PNPublishResult> ret = new PNResult <PNPublishResult>(); if (string.IsNullOrEmpty(channel) || string.IsNullOrEmpty(channel.Trim()) || message == null) { PNStatus errStatus = new PNStatus { Error = true, ErrorData = new PNErrorData("Missing Channel or Message", new ArgumentException("Missing Channel or Message")) }; ret.Status = errStatus; return(ret); } if (string.IsNullOrEmpty(config.PublishKey) || string.IsNullOrEmpty(config.PublishKey.Trim()) || config.PublishKey.Length <= 0) { PNStatus errStatus = new PNStatus { Error = true, ErrorData = new PNErrorData("Invalid publish key", new ArgumentException("Invalid publish key")) }; ret.Status = errStatus; return(ret); } if (string.IsNullOrEmpty(config.SubscribeKey) || string.IsNullOrEmpty(config.SubscribeKey.Trim()) || config.SubscribeKey.Length <= 0) { PNStatus errStatus = new PNStatus { Error = true, ErrorData = new PNErrorData("Invalid subscribe key", new ArgumentException("Invalid subscribe key")) }; ret.Status = errStatus; return(ret); } IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr, (PubnubInstance != null) ? PubnubInstance.InstanceId : ""); Uri request = urlBuilder.BuildSignalRequest("GET", "", channel, message, metaData, externalQueryParam); RequestState <PNPublishResult> requestState = new RequestState <PNPublishResult>(); requestState.Channels = new[] { channel }; requestState.ResponseType = PNOperationType.PNSignalOperation; requestState.Reconnect = false; requestState.EndPointOperation = this; Tuple <string, PNStatus> JsonAndStatusTuple = await UrlProcessRequest(request, requestState, false).ConfigureAwait(false); ret.Status = JsonAndStatusTuple.Item2; string json = JsonAndStatusTuple.Item1; if (!string.IsNullOrEmpty(json)) { List <object> result = ProcessJsonResponse <PNPublishResult>(requestState, json); if (result != null && result.Count >= 3) { int publishStatus; Int32.TryParse(result[0].ToString(), out publishStatus); if (publishStatus == 1) { List <object> resultList = ProcessJsonResponse(requestState, json); if (resultList != null && resultList.Count > 0) { ResponseBuilder responseBuilder = new ResponseBuilder(config, jsonLibrary, pubnubLog); PNPublishResult responseResult = responseBuilder.JsonToObject <PNPublishResult>(resultList, true); if (responseResult != null) { ret.Result = responseResult; } } else { PNStatusCategory category = PNStatusCategoryHelper.GetPNStatusCategory(400, result[1].ToString()); PNStatus status = new StatusBuilder(config, jsonLibrary).CreateStatusResponse <PNPublishResult>(PNOperationType.PNSignalOperation, category, requestState, 400, new PNException(json)); ret.Status = status; ret.Result = default(PNPublishResult); } } } } return(ret); }
private void Signal(string channel, object message, Dictionary <string, object> metaData, Dictionary <string, object> externalQueryParam, PNCallback <PNPublishResult> callback) { if (string.IsNullOrEmpty(channel) || string.IsNullOrEmpty(channel.Trim()) || message == null) { PNStatus status = new PNStatus { Error = true, ErrorData = new PNErrorData("Missing Channel or Message", new ArgumentException("Missing Channel or Message")) }; callback.OnResponse(null, status); return; } if (string.IsNullOrEmpty(config.PublishKey) || string.IsNullOrEmpty(config.PublishKey.Trim()) || config.PublishKey.Length <= 0) { PNStatus status = new PNStatus { Error = true, ErrorData = new PNErrorData("Invalid publish key", new ArgumentException("Invalid publish key")) }; callback.OnResponse(null, status); return; } if (string.IsNullOrEmpty(config.SubscribeKey) || string.IsNullOrEmpty(config.SubscribeKey.Trim()) || config.SubscribeKey.Length <= 0) { PNStatus status = new PNStatus { Error = true, ErrorData = new PNErrorData("Invalid subscribe key", new ArgumentException("Invalid subscribe key")) }; callback.OnResponse(null, status); return; } IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr, (PubnubInstance != null) ? PubnubInstance.InstanceId : ""); Uri request = urlBuilder.BuildSignalRequest("GET", "", channel, message, metaData, externalQueryParam); RequestState <PNPublishResult> requestState = new RequestState <PNPublishResult>(); requestState.Channels = new[] { channel }; requestState.ResponseType = PNOperationType.PNSignalOperation; requestState.PubnubCallback = callback; requestState.Reconnect = false; requestState.EndPointOperation = this; UrlProcessRequest(request, requestState, false).ContinueWith(r => { string json = r.Result.Item1; if (!string.IsNullOrEmpty(json)) { List <object> result = ProcessJsonResponse(requestState, json); if (result != null && result.Count >= 3) { int signalStatus; Int32.TryParse(result[0].ToString(), out signalStatus); if (signalStatus == 1) { ProcessResponseCallbacks(result, requestState); } else { PNStatusCategory category = PNStatusCategoryHelper.GetPNStatusCategory(400, result[1].ToString()); PNStatus status = new StatusBuilder(config, jsonLibrary).CreateStatusResponse <PNPublishResult>(PNOperationType.PNSignalOperation, category, requestState, 400, new PNException(json)); if (requestState.PubnubCallback != null) { requestState.PubnubCallback.OnResponse(default(PNPublishResult), status); } } } else { ProcessResponseCallbacks(result, requestState); } } }, TaskContinuationOptions.ExecuteSynchronously).Wait(); }
public List <object> DecodeDecryptLoop <T>(List <object> message, string[] channels, string[] channelGroups, PNCallback <T> errorCallback) { List <object> returnMessage = new List <object>(); if (config.CipherKey.Length > 0) { PubnubCrypto aes = new PubnubCrypto(config.CipherKey, config, pubnubLog); object[] myObjectArray = (from item in message select item as object).ToArray(); object[] enumerable = myObjectArray[0] as object[]; if (enumerable != null) { List <object> receivedMsg = new List <object>(); foreach (object element in enumerable) { string decryptMessage = ""; try { Dictionary <string, object> historyEnv = jsonLib.ConvertToDictionaryObject(element); if (historyEnv != null && historyEnv.ContainsKey("message")) { string dictionaryValue = aes.Decrypt(historyEnv["message"].ToString()); historyEnv["message"] = jsonLib.DeserializeToObject(dictionaryValue); decryptMessage = jsonLib.SerializeToJsonString(historyEnv); } else { decryptMessage = aes.Decrypt(element.ToString()); } } catch (Exception ex) { decryptMessage = "**DECRYPT ERROR**"; PNStatusCategory category = PNStatusCategoryHelper.GetPNStatusCategory(ex); PNStatus status = new StatusBuilder(config, jsonLib).CreateStatusResponse <T>(PNOperationType.PNHistoryOperation, category, null, (int)HttpStatusCode.NotFound, new PNException(ex)); if (channels != null && channels.Length > 0) { status.AffectedChannels.AddRange(channels); } if (channelGroups != null && channelGroups.Length > 0) { status.AffectedChannelGroups.AddRange(channelGroups); } errorCallback.OnResponse(default(T), status); } object decodeMessage = (decryptMessage == "**DECRYPT ERROR**") ? decryptMessage : jsonLib.DeserializeToObject(decryptMessage); receivedMsg.Add(decodeMessage); } returnMessage.Add(receivedMsg); } for (int index = 1; index < myObjectArray.Length; index++) { returnMessage.Add(myObjectArray[index]); } return(returnMessage); } else { var myObjectArray = (from item in message select item as object).ToArray(); IEnumerable enumerable = myObjectArray[0] as IEnumerable; if (enumerable != null) { List <object> receivedMessage = new List <object>(); foreach (object element in enumerable) { receivedMessage.Add(element); } returnMessage.Add(receivedMessage); } for (int index = 1; index < myObjectArray.Length; index++) { returnMessage.Add(myObjectArray[index]); } return(returnMessage); } }
internal void RaiseError(PNStatusCategory pnStatusCategory, Exception exception, bool showInCallback, RequestState pnRequestState) { this.CreateErrorResponse(pnStatusCategory, exception, showInCallback, pnRequestState); }
private void ProcessFileMessagePublish(Dictionary <string, object> externalQueryParam, PNCallback <PNPublishFileMessageResult> callback) { if (string.IsNullOrEmpty(this.channelName) || string.IsNullOrEmpty(this.channelName.Trim())) { PNStatus status = new PNStatus(); status.Error = true; status.ErrorData = new PNErrorData("Missing Channel or Message", new ArgumentException("Missing Channel or Message")); callback.OnResponse(null, status); return; } Dictionary <string, object> publishPayload = new Dictionary <string, object>(); if (this.msg != null && !string.IsNullOrEmpty(this.msg.ToString())) { publishPayload.Add("message", this.msg); } publishPayload.Add("file", new Dictionary <string, string> { { "id", currentFileId }, { "name", currentFileName } }); RequestState <PNPublishFileMessageResult> requestState = new RequestState <PNPublishFileMessageResult>(); requestState.ResponseType = PNOperationType.PNPublishFileMessageOperation; requestState.PubnubCallback = callback; requestState.Reconnect = false; requestState.EndPointOperation = this; IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr, (PubnubInstance != null) ? PubnubInstance.InstanceId : ""); Uri request = urlBuilder.BuildPublishFileMessageRequest("GET", "", this.channelName, publishPayload, this.storeInHistory, this.ttl, this.userMetadata, null, externalQueryParam); string json = ""; UrlProcessRequest(request, requestState, false).ContinueWith(r => { json = r.Result.Item1; }, TaskContinuationOptions.ExecuteSynchronously).Wait(); if (!string.IsNullOrEmpty(json)) { List <object> result = ProcessJsonResponse(requestState, json); if (result != null && result.Count >= 3) { int publishStatus; Int32.TryParse(result[0].ToString(), out publishStatus); if (publishStatus == 1) { ProcessResponseCallbacks(result, requestState); } else { PNStatusCategory category = PNStatusCategoryHelper.GetPNStatusCategory(400, result[1].ToString()); PNStatus status = new StatusBuilder(config, jsonLibrary).CreateStatusResponse <PNPublishFileMessageResult>(PNOperationType.PNPublishFileMessageOperation, category, requestState, 400, new PNException(json)); if (requestState.PubnubCallback != null) { requestState.PubnubCallback.OnResponse(default(PNPublishFileMessageResult), status); } } } else { ProcessResponseCallbacks(result, requestState); } } }
private void Fire(string channel, object message, bool storeInHistory, int ttl, Dictionary <string, object> metaData, Dictionary <string, object> externalQueryParam, PNCallback <PNPublishResult> callback) { if (string.IsNullOrEmpty(channel) || string.IsNullOrEmpty(channel.Trim()) || message == null) { PNStatus status = new PNStatus { Error = true, ErrorData = new PNErrorData("Missing Channel or Message", new ArgumentException("Missing Channel or Message")) }; callback.OnResponse(null, status); return; } if (string.IsNullOrEmpty(config.PublishKey) || string.IsNullOrEmpty(config.PublishKey.Trim()) || config.PublishKey.Length <= 0) { PNStatus status = new PNStatus { Error = true, ErrorData = new PNErrorData("Invalid publish key", new ArgumentException("Invalid publish key")) }; callback.OnResponse(null, status); return; } if (callback == null) { return; } Dictionary <string, string> urlParam = new Dictionary <string, string>(); urlParam.Add("norep", "true"); string requestMethodName = (this.httpPost) ? "POST" : "GET"; IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr, (PubnubInstance != null) ? PubnubInstance.InstanceId : ""); Uri request = urlBuilder.BuildPublishRequest(requestMethodName, "", channel, message, storeInHistory, ttl, metaData, urlParam, externalQueryParam); RequestState <PNPublishResult> requestState = new RequestState <PNPublishResult>(); requestState.Channels = new [] { channel }; requestState.ResponseType = PNOperationType.PNFireOperation; requestState.PubnubCallback = callback; requestState.Reconnect = false; requestState.EndPointOperation = this; string json = ""; if (this.httpPost) { requestState.UsePostMethod = true; Dictionary <string, object> messageEnvelope = new Dictionary <string, object>(); messageEnvelope.Add("message", message); string postMessage = jsonLibrary.SerializeToJsonString(messageEnvelope); UrlProcessRequest(request, requestState, false, postMessage).ContinueWith(r => { json = r.Result.Item1; }, TaskContinuationOptions.ExecuteSynchronously).Wait(); } else { UrlProcessRequest(request, requestState, false).ContinueWith(r => { json = r.Result.Item1; }, TaskContinuationOptions.ExecuteSynchronously).Wait(); } if (!string.IsNullOrEmpty(json)) { List <object> result = ProcessJsonResponse <PNPublishResult>(requestState, json); if (result != null && result.Count >= 3) { int publishStatus; Int32.TryParse(result[0].ToString(), out publishStatus); if (publishStatus == 1) { ProcessResponseCallbacks(result, requestState); } else { PNStatusCategory category = PNStatusCategoryHelper.GetPNStatusCategory(400, result[1].ToString()); PNStatus status = new StatusBuilder(config, jsonLibrary).CreateStatusResponse <PNPublishResult>(PNOperationType.PNFireOperation, category, requestState, 400, new PNException(json)); if (requestState.PubnubCallback != null) { requestState.PubnubCallback.OnResponse(default(PNPublishResult), status); } } } else { ProcessResponseCallbacks(result, requestState); } } }
public List <object> FetchHistoryDecodeDecryptLoop <T>(PNOperationType type, Dictionary <string, object> messageContainer, string[] channels, string[] channelGroups, PNCallback <T> errorCallback) { List <object> returnMessage = new List <object>(); Dictionary <string, List <object> > dicMessage = new Dictionary <string, List <object> >(); foreach (KeyValuePair <string, object> kvp in messageContainer) { List <object> currentVal = kvp.Value as List <object>; if (currentVal != null) { object[] currentValArray = jsonLib.ConvertToObjectArray(currentVal); List <object> decryptList = (currentValArray != null && currentValArray.Length > 0) ? new List <object>() : null; if (currentValArray != null && decryptList != null) { foreach (object currentObj in currentValArray) { Dictionary <string, object> dicValue = jsonLib.ConvertToDictionaryObject(currentObj); if (dicValue != null && dicValue.Count > 0 && dicValue.ContainsKey("message")) { Dictionary <string, object> dicDecrypt = new Dictionary <string, object>(); foreach (KeyValuePair <string, object> kvpValue in dicValue) { if (kvpValue.Key == "message" && config.CipherKey.Length > 0) { PubnubCrypto aes = new PubnubCrypto(config.CipherKey, config, pubnubLog); string decryptMessage = ""; try { decryptMessage = aes.Decrypt(kvpValue.Value.ToString()); } catch (Exception ex) { #region "Exception" decryptMessage = "**DECRYPT ERROR**"; PNStatusCategory category = PNStatusCategoryHelper.GetPNStatusCategory(ex); PNStatus status = new StatusBuilder(config, jsonLib).CreateStatusResponse <T>(type, category, null, (int)HttpStatusCode.NotFound, new PNException(ex)); if (channels != null && channels.Length > 0) { status.AffectedChannels.AddRange(channels); } if (channelGroups != null && channelGroups.Length > 0) { status.AffectedChannelGroups.AddRange(channelGroups); } errorCallback.OnResponse(default(T), status); #endregion } object decodeMessage = (decryptMessage == "**DECRYPT ERROR**") ? decryptMessage : jsonLib.DeserializeToObject(decryptMessage); dicDecrypt.Add(kvpValue.Key, decodeMessage); } else { dicDecrypt.Add(kvpValue.Key, kvpValue.Value); } } decryptList.Add(dicDecrypt); } } } dicMessage.Add(kvp.Key, decryptList); } } if (dicMessage.Count > 0) { returnMessage.Add(dicMessage); } return(returnMessage); }
protected PNStatus CreateStatusResponseFromMessage(bool isError, string message, RequestState pnRequestState, PNStatusCategory pnStatusCategory) { return(Helpers.CreatePNStatus( pnStatusCategory, message, (isError)?new PubNubException(message):null, isError, OperationType, ChannelsToUse, ChannelGroupsToUse, pnRequestState, PubNubInstance )); }
protected PNStatus CreateErrorResponseFromMessage(string message, RequestState pnRequestState, PNStatusCategory pnStatusCategory) { return(Helpers.CreatePNStatus( pnStatusCategory, message, new PubNubException(message), true, OperationType, ChannelsToUse, ChannelGroupsToUse, pnRequestState, PubNubInstance )); }
public PNStatus CreateStatusResponse <T>(PNOperationType type, PNStatusCategory category, RequestState <T> asyncRequestState, int statusCode, Exception throwable) { PNStatus status = new PNStatus(asyncRequestState != null ? asyncRequestState.EndPointOperation : null); status.Category = category; status.Operation = type; if ((asyncRequestState != null && !asyncRequestState.GotJsonResponse) || throwable != null) { status.Error = true; } if (throwable != null) { if (throwable.InnerException != null) { PNErrorData errorData = new PNErrorData(throwable.InnerException.Message, throwable); status.ErrorData = errorData; } else { PNErrorData errorData = new PNErrorData(throwable.Message, throwable); status.ErrorData = errorData; } } if (asyncRequestState != null) { if (asyncRequestState.Request != null) { status.ClientRequest = asyncRequestState.Request; HttpValueCollection restUriQueryCollection = HttpUtility.ParseQueryString(asyncRequestState.Request.RequestUri.Query); if (restUriQueryCollection.ContainsKey("auth")) { string auth = restUriQueryCollection["auth"]; status.AuthKey = auth; } if (restUriQueryCollection.ContainsKey("uuid")) { string uuid = restUriQueryCollection["uuid"]; status.Uuid = uuid; } } if (asyncRequestState.Response != null) { status.StatusCode = (int)asyncRequestState.Response.StatusCode; } else { status.StatusCode = statusCode; } if (asyncRequestState.ChannelGroups != null) { status.AffectedChannelGroups = asyncRequestState.ChannelGroups.ToList <string>(); } if (asyncRequestState.Channels != null) { status.AffectedChannels = asyncRequestState.Channels.ToList <string>(); } } else { status.StatusCode = statusCode; } status.Origin = config.Origin; status.TlsEnabled = config.Secure; return(status); }
public PNStatus CreateStatusResponse <T>(PNOperationType type, PNStatusCategory category, RequestState <T> asyncRequestState, int statusCode, PNException throwable) { int serverErrorStatusCode = 0; bool serverErrorMessage = false; List <string> serverAffectedChannels = null; List <string> serverAffectedChannelGroups = null; PNStatus status = new PNStatus(asyncRequestState != null ? asyncRequestState.EndPointOperation : null); status.Category = category; status.Operation = type; if ((asyncRequestState != null && !asyncRequestState.GotJsonResponse) || throwable != null) { status.Error = true; } Exception targetException = null; if (throwable != null) { if (throwable.DirectException) { targetException = throwable.InnerException; } else { targetException = throwable as Exception; } } if (targetException != null) { if (targetException.InnerException != null) { PNErrorData errorData = new PNErrorData(jsonLibrary.SerializeToJsonString(targetException.InnerException.Message), targetException); status.ErrorData = errorData; } else { Dictionary <string, object> deserializeStatus = jsonLibrary.DeserializeToDictionaryOfObject(targetException.Message); if (deserializeStatus != null && deserializeStatus.Count >= 1 && deserializeStatus.ContainsKey("error") && string.Equals(deserializeStatus["error"].ToString(), "true", StringComparison.CurrentCultureIgnoreCase) && deserializeStatus.ContainsKey("status") && Int32.TryParse(deserializeStatus["status"].ToString(), out serverErrorStatusCode)) { serverErrorMessage = true; if (deserializeStatus.ContainsKey("payload")) { Dictionary <string, object> payloadDic = jsonLibrary.ConvertToDictionaryObject(deserializeStatus["payload"]); if (payloadDic != null && payloadDic.Count > 0) { if (payloadDic.ContainsKey("channels")) { object[] chDic = jsonLibrary.ConvertToObjectArray(payloadDic["channels"]); if (chDic != null && chDic.Length > 0) { serverAffectedChannels = chDic.Select(x => x.ToString()).ToList(); } } if (payloadDic.ContainsKey("channel-groups")) { object[] cgDic = jsonLibrary.ConvertToObjectArray(payloadDic["channel-groups"]); if (cgDic != null && cgDic.Length > 0) { serverAffectedChannelGroups = cgDic.Select(x => x.ToString()).ToList(); } } } } } PNErrorData errorData = new PNErrorData(jsonLibrary.SerializeToJsonString(targetException.Message), targetException); status.ErrorData = errorData; } } if (asyncRequestState != null) { if (asyncRequestState.Request != null) { status.ClientRequest = asyncRequestState.Request; HttpValueCollection restUriQueryCollection = HttpUtility.ParseQueryString(asyncRequestState.Request.RequestUri.Query); if (restUriQueryCollection.ContainsKey("auth")) { string auth = restUriQueryCollection["auth"]; status.AuthKey = auth; } if (restUriQueryCollection.ContainsKey("uuid")) { string uuid = restUriQueryCollection["uuid"]; status.Uuid = uuid; } } if (serverErrorMessage && serverErrorStatusCode > 0) { status.StatusCode = serverErrorStatusCode; } else if (asyncRequestState.Response != null) { status.StatusCode = (int)asyncRequestState.Response.StatusCode; } else { status.StatusCode = statusCode; } if (serverErrorMessage) { status.AffectedChannels = serverAffectedChannels; status.AffectedChannelGroups = serverAffectedChannelGroups; } else { if (asyncRequestState.ChannelGroups != null) { status.AffectedChannelGroups = asyncRequestState.ChannelGroups.ToList <string>(); } if (asyncRequestState.Channels != null) { status.AffectedChannels = asyncRequestState.Channels.ToList <string>(); } } } else { status.StatusCode = statusCode; } if (status.StatusCode == 403) { status.Category = PNStatusCategory.PNAccessDeniedCategory; } status.Origin = config.Origin; status.TlsEnabled = config.Secure; return(status); }
public static bool TryCheckErrorTypeAndCallback <T> (CustomEventArgs cea, PubNubUnity pnUnity, out PNStatus pnStatus) { bool retBool = false; PNStatusCategory pnStatusCat = PNStatusCategory.PNUnknownCategory; if (cea.IsTimeout || CheckRequestTimeoutMessageInError(cea)) { pnStatusCat = PNStatusCategory.PNTimeoutCategory; retBool = true; } else if (cea.IsError) { if ((cea.Message.Contains("NameResolutionFailure") || cea.Message.Contains("ConnectFailure") || cea.Message.Contains("ServerProtocolViolation") || cea.Message.Contains("ProtocolError") )) { pnStatusCat = PNStatusCategory.PNNetworkIssuesCategory; } else if (cea.Message.Contains("Aborted")) { pnStatusCat = PNStatusCategory.PNCancelledCategory; } else if ((cea.Message.Contains("403")) || (cea.Message.Contains("java.io.FileNotFoundException")) || ((pnUnity.Version.Contains("UnityWeb")) && (cea.Message.Contains("Failed downloading")))) { pnStatusCat = PNStatusCategory.PNAccessDeniedCategory; } else if (cea.PubNubRequestState != null) { switch (cea.PubNubRequestState.ResponseCode) { case 403: pnStatusCat = PNStatusCategory.PNAccessDeniedCategory; break; case 500: case 502: case 503: case 481: case 451: pnStatusCat = PNStatusCategory.PNUnexpectedDisconnectCategory; break; case 504: pnStatusCat = PNStatusCategory.PNTimeoutCategory; break; case 414: case 400: pnStatusCat = PNStatusCategory.PNBadRequestCategory; break; default: pnStatusCat = PNStatusCategory.PNUnknownCategory; break; } } retBool = true; } else { retBool = false; } if (retBool) { pnStatus = CreatePNStatus( pnStatusCat, cea.Message, null, retBool, PNOperationType.PNSubscribeOperation, pnUnity.SubscriptionInstance.AllChannels, pnUnity.SubscriptionInstance.AllChannelGroups, cea.PubNubRequestState, pnUnity ); } else { pnStatus = null; } return(retBool); }
private void Publish(string channel, object message, bool storeInHistory, int ttl, Dictionary <string, object> metaData, Dictionary <string, object> externalQueryParam, PNCallback <PNPublishResult> callback) { if (string.IsNullOrEmpty(channel) || string.IsNullOrEmpty(channel.Trim()) || message == null) { PNStatus status = new PNStatus(); status.Error = true; status.ErrorData = new PNErrorData("Missing Channel or Message", new ArgumentException("Missing Channel or Message")); callback.OnResponse(null, status); return; } if (string.IsNullOrEmpty(config.PublishKey) || string.IsNullOrEmpty(config.PublishKey.Trim()) || config.PublishKey.Length <= 0) { PNStatus status = new PNStatus(); status.Error = true; status.ErrorData = new PNErrorData("Invalid publish key", new MissingMemberException("Invalid publish key")); callback.OnResponse(null, status); return; } if (callback == null) { return; } IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr); urlBuilder.PubnubInstanceId = (PubnubInstance != null) ? PubnubInstance.InstanceId : ""; Uri request = urlBuilder.BuildPublishRequest(channel, message, storeInHistory, ttl, metaData, httpPost, null, externalQueryParam); RequestState <PNPublishResult> requestState = new RequestState <PNPublishResult>(); requestState.Channels = new [] { channel }; requestState.ResponseType = PNOperationType.PNPublishOperation; requestState.PubnubCallback = callback; requestState.Reconnect = false; requestState.EndPointOperation = this; string json = ""; if (this.httpPost) { requestState.UsePostMethod = true; string postMessage = JsonEncodePublishMsg(message); json = UrlProcessRequest <PNPublishResult>(request, requestState, false, postMessage); } else { json = UrlProcessRequest <PNPublishResult>(request, requestState, false); } if (!string.IsNullOrEmpty(json)) { List <object> result = ProcessJsonResponse <PNPublishResult>(requestState, json); if (result != null && result.Count >= 3) { int publishStatus; Int32.TryParse(result[0].ToString(), out publishStatus); if (publishStatus == 1) { ProcessResponseCallbacks(result, requestState); } else { PNStatusCategory category = PNStatusCategoryHelper.GetPNStatusCategory(400, result[1].ToString()); PNStatus status = new StatusBuilder(config, jsonLibrary).CreateStatusResponse <PNPublishResult>(PNOperationType.PNPublishOperation, category, requestState, 400, new PNException(json)); if (requestState.PubnubCallback != null) { requestState.PubnubCallback.OnResponse(default(PNPublishResult), status); } } } else { ProcessResponseCallbacks(result, requestState); } } CleanUp(); }
public void Initialize(bool isError, PNStatusCategory category, Exception exception = null) { BaseInitialize(isError, exception); Category = category; }
protected PNStatus CreateErrorResponseFromException(Exception ex, RequestState pnRequestState, PNStatusCategory pnStatusCategory) { return(Helpers.CreatePNStatus( pnStatusCategory, ex.Message, ex, true, OperationType, ChannelsToUse, ChannelGroupsToUse, pnRequestState, PubNubInstance )); }