How to use Connection method in Cypress

Best JavaScript code snippet using cypress

jquery.signalR-2.2.2.js

Source:jquery.signalR-2.2.2.js Github

copy

Full Screen

...838 // Check if the keep alive has completely timed out839 if (timeElapsed >= keepAliveData.timeout) {840 connection.log("Keep alive timed out. Notifying transport that connection has been lost.");841 // Notify transport that the connection has been lost842 connection.transport.lostConnection(connection);843 } else if (timeElapsed >= keepAliveData.timeoutWarning) {844 // This is to assure that the user only gets a single warning845 if (!keepAliveData.userNotified) {846 connection.log("Keep alive has been missed, connection may be dead/slow.");847 $(connection).triggerHandler(events.onConnectionSlow);848 keepAliveData.userNotified = true;849 }850 } else {851 keepAliveData.userNotified = false;852 }853 }854 }855 function getAjaxUrl(connection, path) {856 var url = connection.url + path;857 if (connection.transport) {858 url += "?transport=" + connection.transport.name;859 }860 return transportLogic.prepareQueryString(connection, url);861 }862 function InitHandler(connection) {863 this.connection = connection;864 this.startRequested = false;865 this.startCompleted = false;866 this.connectionStopped = false;867 }868 InitHandler.prototype = {869 start: function (transport, onSuccess, onFallback) {870 var that = this,871 connection = that.connection,872 failCalled = false;873 if (that.startRequested || that.connectionStopped) {874 connection.log("WARNING! " + transport.name + " transport cannot be started. Initialization ongoing or completed.");875 return;876 }877 connection.log(transport.name + " transport starting.");878 transport.start(connection, function () {879 if (!failCalled) {880 that.initReceived(transport, onSuccess);881 }882 }, function (error) {883 // Don't allow the same transport to cause onFallback to be called twice884 if (!failCalled) {885 failCalled = true;886 that.transportFailed(transport, error, onFallback);887 }888 // Returns true if the transport should stop;889 // false if it should attempt to reconnect890 return !that.startCompleted || that.connectionStopped;891 });892 that.transportTimeoutHandle = window.setTimeout(function () {893 if (!failCalled) {894 failCalled = true;895 connection.log(transport.name + " transport timed out when trying to connect.");896 that.transportFailed(transport, undefined, onFallback);897 }898 }, connection._.totalTransportConnectTimeout);899 },900 stop: function () {901 this.connectionStopped = true;902 window.clearTimeout(this.transportTimeoutHandle);903 signalR.transports._logic.tryAbortStartRequest(this.connection);904 },905 initReceived: function (transport, onSuccess) {906 var that = this,907 connection = that.connection;908 if (that.startRequested) {909 connection.log("WARNING! The client received multiple init messages.");910 return;911 }912 if (that.connectionStopped) {913 return;914 }915 that.startRequested = true;916 window.clearTimeout(that.transportTimeoutHandle);917 connection.log(transport.name + " transport connected. Initiating start request.");918 signalR.transports._logic.ajaxStart(connection, function () {919 that.startCompleted = true;920 onSuccess();921 });922 },923 transportFailed: function (transport, error, onFallback) {924 var connection = this.connection,925 deferred = connection._deferral,926 wrappedError;927 if (this.connectionStopped) {928 return;929 }930 window.clearTimeout(this.transportTimeoutHandle);931 if (!this.startRequested) {932 transport.stop(connection);933 connection.log(transport.name + " transport failed to connect. Attempting to fall back.");934 onFallback();935 } else if (!this.startCompleted) {936 // Do not attempt to fall back if a start request is ongoing during a transport failure.937 // Instead, trigger an error and stop the connection.938 wrappedError = signalR._.error(signalR.resources.errorDuringStartRequest, error);939 connection.log(transport.name + " transport failed during the start request. Stopping the connection.");940 $(connection).triggerHandler(events.onError, [wrappedError]);941 if (deferred) {942 deferred.reject(wrappedError);943 }944 connection.stop();945 } else {946 // The start request has completed, but the connection has not stopped.947 // No need to do anything here. The transport should attempt its normal reconnect logic.948 }949 }950 };951 transportLogic = signalR.transports._logic = {952 ajax: function (connection, options) {953 return $.ajax(954 $.extend(/*deep copy*/ true, {}, $.signalR.ajaxDefaults, {955 type: "GET",956 data: {},957 xhrFields: { withCredentials: connection.withCredentials },958 contentType: connection.contentType,959 dataType: connection.ajaxDataType960 }, options));961 },962 pingServer: function (connection) {963 /// <summary>Pings the server</summary>964 /// <param name="connection" type="signalr">Connection associated with the server ping</param>965 /// <returns type="signalR" />966 var url,967 xhr,968 deferral = $.Deferred();969 if (connection.transport) {970 url = connection.url + "/ping";971 url = transportLogic.addQs(url, connection.qs);972 xhr = transportLogic.ajax(connection, {973 url: url,974 success: function (result) {975 var data;976 try {977 data = connection._parseResponse(result);978 }979 catch (error) {980 deferral.reject(981 signalR._.transportError(982 signalR.resources.pingServerFailedParse,983 connection.transport,984 error,985 xhr986 )987 );988 connection.stop();989 return;990 }991 if (data.Response === "pong") {992 deferral.resolve();993 }994 else {995 deferral.reject(996 signalR._.transportError(997 signalR._.format(signalR.resources.pingServerFailedInvalidResponse, result),998 connection.transport,999 null /* error */,1000 xhr1001 )1002 );1003 }1004 },1005 error: function (error) {1006 if (error.status === 401 || error.status === 403) {1007 deferral.reject(1008 signalR._.transportError(1009 signalR._.format(signalR.resources.pingServerFailedStatusCode, error.status),1010 connection.transport,1011 error,1012 xhr1013 )1014 );1015 connection.stop();1016 }1017 else {1018 deferral.reject(1019 signalR._.transportError(1020 signalR.resources.pingServerFailed,1021 connection.transport,1022 error,1023 xhr1024 )1025 );1026 }1027 }1028 });1029 }1030 else {1031 deferral.reject(1032 signalR._.transportError(1033 signalR.resources.noConnectionTransport,1034 connection.transport1035 )1036 );1037 }1038 return deferral.promise();1039 },1040 prepareQueryString: function (connection, url) {1041 var preparedUrl;1042 // Use addQs to start since it handles the ?/& prefix for us1043 preparedUrl = transportLogic.addQs(url, "clientProtocol=" + connection.clientProtocol);1044 // Add the user-specified query string params if any1045 preparedUrl = transportLogic.addQs(preparedUrl, connection.qs);1046 if (connection.token) {1047 preparedUrl += "&connectionToken=" + window.encodeURIComponent(connection.token);1048 }1049 if (connection.data) {1050 preparedUrl += "&connectionData=" + window.encodeURIComponent(connection.data);1051 }1052 return preparedUrl;1053 },1054 addQs: function (url, qs) {1055 var appender = url.indexOf("?") !== -1 ? "&" : "?",1056 firstChar;1057 if (!qs) {1058 return url;1059 }1060 if (typeof (qs) === "object") {1061 return url + appender + $.param(qs);1062 }1063 if (typeof (qs) === "string") {1064 firstChar = qs.charAt(0);1065 if (firstChar === "?" || firstChar === "&") {1066 appender = "";1067 }1068 return url + appender + qs;1069 }1070 throw new Error("Query string property must be either a string or object.");1071 },1072 // BUG #2953: The url needs to be same otherwise it will cause a memory leak1073 getUrl: function (connection, transport, reconnecting, poll, ajaxPost) {1074 /// <summary>Gets the url for making a GET based connect request</summary>1075 var baseUrl = transport === "webSockets" ? "" : connection.baseUrl,1076 url = baseUrl + connection.appRelativeUrl,1077 qs = "transport=" + transport;1078 if (!ajaxPost && connection.groupsToken) {1079 qs += "&groupsToken=" + window.encodeURIComponent(connection.groupsToken);1080 }1081 if (!reconnecting) {1082 url += "/connect";1083 } else {1084 if (poll) {1085 // longPolling transport specific1086 url += "/poll";1087 } else {1088 url += "/reconnect";1089 }1090 if (!ajaxPost && connection.messageId) {1091 qs += "&messageId=" + window.encodeURIComponent(connection.messageId);1092 }1093 }1094 url += "?" + qs;1095 url = transportLogic.prepareQueryString(connection, url);1096 if (!ajaxPost) {1097 url += "&tid=" + Math.floor(Math.random() * 11);1098 }1099 return url;1100 },1101 maximizePersistentResponse: function (minPersistentResponse) {1102 return {1103 MessageId: minPersistentResponse.C,1104 Messages: minPersistentResponse.M,1105 Initialized: typeof (minPersistentResponse.S) !== "undefined" ? true : false,1106 ShouldReconnect: typeof (minPersistentResponse.T) !== "undefined" ? true : false,1107 LongPollDelay: minPersistentResponse.L,1108 GroupsToken: minPersistentResponse.G1109 };1110 },1111 updateGroups: function (connection, groupsToken) {1112 if (groupsToken) {1113 connection.groupsToken = groupsToken;1114 }1115 },1116 stringifySend: function (connection, message) {1117 if (typeof (message) === "string" || typeof (message) === "undefined" || message === null) {1118 return message;1119 }1120 return connection.json.stringify(message);1121 },1122 ajaxSend: function (connection, data) {1123 var payload = transportLogic.stringifySend(connection, data),1124 url = getAjaxUrl(connection, "/send"),1125 xhr,1126 onFail = function (error, connection) {1127 $(connection).triggerHandler(events.onError, [signalR._.transportError(signalR.resources.sendFailed, connection.transport, error, xhr), data]);1128 };1129 xhr = transportLogic.ajax(connection, {1130 url: url,1131 type: connection.ajaxDataType === "jsonp" ? "GET" : "POST",1132 contentType: signalR._.defaultContentType,1133 data: {1134 data: payload1135 },1136 success: function (result) {1137 var res;1138 if (result) {1139 try {1140 res = connection._parseResponse(result);1141 }1142 catch (error) {1143 onFail(error, connection);1144 connection.stop();1145 return;1146 }1147 transportLogic.triggerReceived(connection, res);1148 }1149 },1150 error: function (error, textStatus) {1151 if (textStatus === "abort" || textStatus === "parsererror") {1152 // The parsererror happens for sends that don't return any data, and hence1153 // don't write the jsonp callback to the response. This is harder to fix on the server1154 // so just hack around it on the client for now.1155 return;1156 }1157 onFail(error, connection);1158 }1159 });1160 return xhr;1161 },1162 ajaxAbort: function (connection, async) {1163 if (typeof (connection.transport) === "undefined") {1164 return;1165 }1166 // Async by default unless explicitly overidden1167 async = typeof async === "undefined" ? true : async;1168 var url = getAjaxUrl(connection, "/abort");1169 transportLogic.ajax(connection, {1170 url: url,1171 async: async,1172 timeout: 1000,1173 type: "POST"1174 });1175 connection.log("Fired ajax abort async = " + async + ".");1176 },1177 ajaxStart: function (connection, onSuccess) {1178 var rejectDeferred = function (error) {1179 var deferred = connection._deferral;1180 if (deferred) {1181 deferred.reject(error);1182 }1183 },1184 triggerStartError = function (error) {1185 connection.log("The start request failed. Stopping the connection.");1186 $(connection).triggerHandler(events.onError, [error]);1187 rejectDeferred(error);1188 connection.stop();1189 };1190 connection._.startRequest = transportLogic.ajax(connection, {1191 url: getAjaxUrl(connection, "/start"),1192 success: function (result, statusText, xhr) {1193 var data;1194 try {1195 data = connection._parseResponse(result);1196 } catch (error) {1197 triggerStartError(signalR._.error(1198 signalR._.format(signalR.resources.errorParsingStartResponse, result),1199 error, xhr));1200 return;1201 }1202 if (data.Response === "started") {1203 onSuccess();1204 } else {1205 triggerStartError(signalR._.error(1206 signalR._.format(signalR.resources.invalidStartResponse, result),1207 null /* error */, xhr));1208 }1209 },1210 error: function (xhr, statusText, error) {1211 if (statusText !== startAbortText) {1212 triggerStartError(signalR._.error(1213 signalR.resources.errorDuringStartRequest,1214 error, xhr));1215 } else {1216 // Stop has been called, no need to trigger the error handler1217 // or stop the connection again with onStartError1218 connection.log("The start request aborted because connection.stop() was called.");1219 rejectDeferred(signalR._.error(1220 signalR.resources.stoppedDuringStartRequest,1221 null /* error */, xhr));1222 }1223 }1224 });1225 },1226 tryAbortStartRequest: function (connection) {1227 if (connection._.startRequest) {1228 // If the start request has already completed this will noop.1229 connection._.startRequest.abort(startAbortText);1230 delete connection._.startRequest;1231 }1232 },1233 tryInitialize: function (connection, persistentResponse, onInitialized) {1234 if (persistentResponse.Initialized && onInitialized) {1235 onInitialized();1236 } else if (persistentResponse.Initialized) {1237 connection.log("WARNING! The client received an init message after reconnecting.");1238 }1239 },1240 triggerReceived: function (connection, data) {1241 if (!connection._.connectingMessageBuffer.tryBuffer(data)) {1242 $(connection).triggerHandler(events.onReceived, [data]);1243 }1244 },1245 processMessages: function (connection, minData, onInitialized) {1246 var data;1247 // Update the last message time stamp1248 transportLogic.markLastMessage(connection);1249 if (minData) {1250 data = transportLogic.maximizePersistentResponse(minData);1251 transportLogic.updateGroups(connection, data.GroupsToken);1252 if (data.MessageId) {1253 connection.messageId = data.MessageId;1254 }1255 if (data.Messages) {1256 $.each(data.Messages, function (index, message) {1257 transportLogic.triggerReceived(connection, message);1258 });1259 transportLogic.tryInitialize(connection, data, onInitialized);1260 }1261 }1262 },1263 monitorKeepAlive: function (connection) {1264 var keepAliveData = connection._.keepAliveData;1265 // If we haven't initiated the keep alive timeouts then we need to1266 if (!keepAliveData.monitoring) {1267 keepAliveData.monitoring = true;1268 transportLogic.markLastMessage(connection);1269 // Save the function so we can unbind it on stop1270 connection._.keepAliveData.reconnectKeepAliveUpdate = function () {1271 // Mark a new message so that keep alive doesn't time out connections1272 transportLogic.markLastMessage(connection);1273 };1274 // Update Keep alive on reconnect1275 $(connection).bind(events.onReconnect, connection._.keepAliveData.reconnectKeepAliveUpdate);1276 connection.log("Now monitoring keep alive with a warning timeout of " + keepAliveData.timeoutWarning + ", keep alive timeout of " + keepAliveData.timeout + " and disconnecting timeout of " + connection.disconnectTimeout);1277 } else {1278 connection.log("Tried to monitor keep alive but it's already being monitored.");1279 }1280 },1281 stopMonitoringKeepAlive: function (connection) {1282 var keepAliveData = connection._.keepAliveData;1283 // Only attempt to stop the keep alive monitoring if its being monitored1284 if (keepAliveData.monitoring) {1285 // Stop monitoring1286 keepAliveData.monitoring = false;1287 // Remove the updateKeepAlive function from the reconnect event1288 $(connection).unbind(events.onReconnect, connection._.keepAliveData.reconnectKeepAliveUpdate);1289 // Clear all the keep alive data1290 connection._.keepAliveData = {};1291 connection.log("Stopping the monitoring of the keep alive.");1292 }1293 },1294 startHeartbeat: function (connection) {1295 connection._.lastActiveAt = new Date().getTime();1296 beat(connection);1297 },1298 markLastMessage: function (connection) {1299 connection._.lastMessageAt = new Date().getTime();1300 },1301 markActive: function (connection) {1302 if (transportLogic.verifyLastActive(connection)) {1303 connection._.lastActiveAt = new Date().getTime();1304 return true;1305 }1306 return false;1307 },1308 isConnectedOrReconnecting: function (connection) {1309 return connection.state === signalR.connectionState.connected ||1310 connection.state === signalR.connectionState.reconnecting;1311 },1312 ensureReconnectingState: function (connection) {1313 if (changeState(connection,1314 signalR.connectionState.connected,1315 signalR.connectionState.reconnecting) === true) {1316 $(connection).triggerHandler(events.onReconnecting);1317 }1318 return connection.state === signalR.connectionState.reconnecting;1319 },1320 clearReconnectTimeout: function (connection) {1321 if (connection && connection._.reconnectTimeout) {1322 window.clearTimeout(connection._.reconnectTimeout);1323 delete connection._.reconnectTimeout;1324 }1325 },1326 verifyLastActive: function (connection) {1327 if (new Date().getTime() - connection._.lastActiveAt >= connection.reconnectWindow) {1328 var message = signalR._.format(signalR.resources.reconnectWindowTimeout, new Date(connection._.lastActiveAt), connection.reconnectWindow);1329 connection.log(message);1330 $(connection).triggerHandler(events.onError, [signalR._.error(message, /* source */ "TimeoutException")]);1331 connection.stop(/* async */ false, /* notifyServer */ false);1332 return false;1333 }1334 return true;1335 },1336 reconnect: function (connection, transportName) {1337 var transport = signalR.transports[transportName];1338 // We should only set a reconnectTimeout if we are currently connected1339 // and a reconnectTimeout isn't already set.1340 if (transportLogic.isConnectedOrReconnecting(connection) && !connection._.reconnectTimeout) {1341 // Need to verify before the setTimeout occurs because an application sleep could occur during the setTimeout duration.1342 if (!transportLogic.verifyLastActive(connection)) {1343 return;1344 }1345 connection._.reconnectTimeout = window.setTimeout(function () {1346 if (!transportLogic.verifyLastActive(connection)) {1347 return;1348 }1349 transport.stop(connection);1350 if (transportLogic.ensureReconnectingState(connection)) {1351 connection.log(transportName + " reconnecting.");1352 transport.start(connection);1353 }1354 }, connection.reconnectDelay);1355 }1356 },1357 handleParseFailure: function (connection, result, error, onFailed, context) {1358 var wrappedError = signalR._.transportError(1359 signalR._.format(signalR.resources.parseFailed, result),1360 connection.transport,1361 error,1362 context);1363 // If we're in the initialization phase trigger onFailed, otherwise stop the connection.1364 if (onFailed && onFailed(wrappedError)) {1365 connection.log("Failed to parse server response while attempting to connect.");1366 } else {1367 $(connection).triggerHandler(events.onError, [wrappedError]);1368 connection.stop();1369 }1370 },1371 initHandler: function (connection) {1372 return new InitHandler(connection);1373 },1374 foreverFrame: {1375 count: 0,1376 connections: {}1377 }1378 };1379}(window.jQuery, window));1380/* jquery.signalR.transports.webSockets.js */1381// Copyright (c) .NET Foundation. All rights reserved.1382// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.1383/*global window:false */1384/// <reference path="jquery.signalR.transports.common.js" />1385(function ($, window, undefined) {1386 var signalR = $.signalR,1387 events = $.signalR.events,1388 changeState = $.signalR.changeState,1389 transportLogic = signalR.transports._logic;1390 signalR.transports.webSockets = {1391 name: "webSockets",1392 supportsKeepAlive: function () {1393 return true;1394 },1395 send: function (connection, data) {1396 var payload = transportLogic.stringifySend(connection, data);1397 try {1398 connection.socket.send(payload);1399 } catch (ex) {1400 $(connection).triggerHandler(events.onError,1401 [signalR._.transportError(1402 signalR.resources.webSocketsInvalidState,1403 connection.transport,1404 ex,1405 connection.socket1406 ),1407 data]);1408 }1409 },1410 start: function (connection, onSuccess, onFailed) {1411 var url,1412 opened = false,1413 that = this,1414 reconnecting = !onSuccess,1415 $connection = $(connection);1416 if (!window.WebSocket) {1417 onFailed();1418 return;1419 }1420 if (!connection.socket) {1421 if (connection.webSocketServerUrl) {1422 url = connection.webSocketServerUrl;1423 } else {1424 url = connection.wsProtocol + connection.host;1425 }1426 url += transportLogic.getUrl(connection, this.name, reconnecting);1427 connection.log("Connecting to websocket endpoint '" + url + "'.");1428 connection.socket = new window.WebSocket(url);1429 connection.socket.onopen = function () {1430 opened = true;1431 connection.log("Websocket opened.");1432 transportLogic.clearReconnectTimeout(connection);1433 if (changeState(connection,1434 signalR.connectionState.reconnecting,1435 signalR.connectionState.connected) === true) {1436 $connection.triggerHandler(events.onReconnect);1437 }1438 };1439 connection.socket.onclose = function (event) {1440 var error;1441 // Only handle a socket close if the close is from the current socket.1442 // Sometimes on disconnect the server will push down an onclose event1443 // to an expired socket.1444 if (this === connection.socket) {1445 if (opened && typeof event.wasClean !== "undefined" && event.wasClean === false) {1446 // Ideally this would use the websocket.onerror handler (rather than checking wasClean in onclose) but1447 // I found in some circumstances Chrome won't call onerror. This implementation seems to work on all browsers.1448 error = signalR._.transportError(1449 signalR.resources.webSocketClosed,1450 connection.transport,1451 event);1452 connection.log("Unclean disconnect from websocket: " + (event.reason || "[no reason given]."));1453 } else {1454 connection.log("Websocket closed.");1455 }1456 if (!onFailed || !onFailed(error)) {1457 if (error) {1458 $(connection).triggerHandler(events.onError, [error]);1459 }1460 that.reconnect(connection);1461 }1462 }1463 };1464 connection.socket.onmessage = function (event) {1465 var data;1466 try {1467 data = connection._parseResponse(event.data);1468 }1469 catch (error) {1470 transportLogic.handleParseFailure(connection, event.data, error, onFailed, event);1471 return;1472 }1473 if (data) {1474 // data.M is PersistentResponse.Messages1475 if ($.isEmptyObject(data) || data.M) {1476 transportLogic.processMessages(connection, data, onSuccess);1477 } else {1478 // For websockets we need to trigger onReceived1479 // for callbacks to outgoing hub calls.1480 transportLogic.triggerReceived(connection, data);1481 }1482 }1483 };1484 }1485 },1486 reconnect: function (connection) {1487 transportLogic.reconnect(connection, this.name);1488 },1489 lostConnection: function (connection) {1490 this.reconnect(connection);1491 },1492 stop: function (connection) {1493 // Don't trigger a reconnect after stopping1494 transportLogic.clearReconnectTimeout(connection);1495 if (connection.socket) {1496 connection.log("Closing the Websocket.");1497 connection.socket.close();1498 connection.socket = null;1499 }1500 },1501 abort: function (connection, async) {1502 transportLogic.ajaxAbort(connection, async);1503 }1504 };1505}(window.jQuery, window));1506/* jquery.signalR.transports.serverSentEvents.js */1507// Copyright (c) .NET Foundation. All rights reserved.1508// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.1509/*global window:false */1510/// <reference path="jquery.signalR.transports.common.js" />1511(function ($, window, undefined) {1512 var signalR = $.signalR,1513 events = $.signalR.events,1514 changeState = $.signalR.changeState,1515 transportLogic = signalR.transports._logic,1516 clearReconnectAttemptTimeout = function (connection) {1517 window.clearTimeout(connection._.reconnectAttemptTimeoutHandle);1518 delete connection._.reconnectAttemptTimeoutHandle;1519 };1520 signalR.transports.serverSentEvents = {1521 name: "serverSentEvents",1522 supportsKeepAlive: function () {1523 return true;1524 },1525 timeOut: 3000,1526 start: function (connection, onSuccess, onFailed) {1527 var that = this,1528 opened = false,1529 $connection = $(connection),1530 reconnecting = !onSuccess,1531 url;1532 if (connection.eventSource) {1533 connection.log("The connection already has an event source. Stopping it.");1534 connection.stop();1535 }1536 if (!window.EventSource) {1537 if (onFailed) {1538 connection.log("This browser doesn't support SSE.");1539 onFailed();1540 }1541 return;1542 }1543 url = transportLogic.getUrl(connection, this.name, reconnecting);1544 try {1545 connection.log("Attempting to connect to SSE endpoint '" + url + "'.");1546 connection.eventSource = new window.EventSource(url, { withCredentials: connection.withCredentials });1547 }1548 catch (e) {1549 connection.log("EventSource failed trying to connect with error " + e.Message + ".");1550 if (onFailed) {1551 // The connection failed, call the failed callback1552 onFailed();1553 } else {1554 $connection.triggerHandler(events.onError, [signalR._.transportError(signalR.resources.eventSourceFailedToConnect, connection.transport, e)]);1555 if (reconnecting) {1556 // If we were reconnecting, rather than doing initial connect, then try reconnect again1557 that.reconnect(connection);1558 }1559 }1560 return;1561 }1562 if (reconnecting) {1563 connection._.reconnectAttemptTimeoutHandle = window.setTimeout(function () {1564 if (opened === false) {1565 // If we're reconnecting and the event source is attempting to connect,1566 // don't keep retrying. This causes duplicate connections to spawn.1567 if (connection.eventSource.readyState !== window.EventSource.OPEN) {1568 // If we were reconnecting, rather than doing initial connect, then try reconnect again1569 that.reconnect(connection);1570 }1571 }1572 },1573 that.timeOut);1574 }1575 connection.eventSource.addEventListener("open", function (e) {1576 connection.log("EventSource connected.");1577 clearReconnectAttemptTimeout(connection);1578 transportLogic.clearReconnectTimeout(connection);1579 if (opened === false) {1580 opened = true;1581 if (changeState(connection,1582 signalR.connectionState.reconnecting,1583 signalR.connectionState.connected) === true) {1584 $connection.triggerHandler(events.onReconnect);1585 }1586 }1587 }, false);1588 connection.eventSource.addEventListener("message", function (e) {1589 var res;1590 // process messages1591 if (e.data === "initialized") {1592 return;1593 }1594 try {1595 res = connection._parseResponse(e.data);1596 }1597 catch (error) {1598 transportLogic.handleParseFailure(connection, e.data, error, onFailed, e);1599 return;1600 }1601 transportLogic.processMessages(connection, res, onSuccess);1602 }, false);1603 connection.eventSource.addEventListener("error", function (e) {1604 var error = signalR._.transportError(1605 signalR.resources.eventSourceError,1606 connection.transport,1607 e);1608 // Only handle an error if the error is from the current Event Source.1609 // Sometimes on disconnect the server will push down an error event1610 // to an expired Event Source.1611 if (this !== connection.eventSource) {1612 return;1613 }1614 if (onFailed && onFailed(error)) {1615 return;1616 }1617 connection.log("EventSource readyState: " + connection.eventSource.readyState + ".");1618 if (e.eventPhase === window.EventSource.CLOSED) {1619 // We don't use the EventSource's native reconnect function as it1620 // doesn't allow us to change the URL when reconnecting. We need1621 // to change the URL to not include the /connect suffix, and pass1622 // the last message id we received.1623 connection.log("EventSource reconnecting due to the server connection ending.");1624 that.reconnect(connection);1625 } else {1626 // connection error1627 connection.log("EventSource error.");1628 $connection.triggerHandler(events.onError, [error]);1629 }1630 }, false);1631 },1632 reconnect: function (connection) {1633 transportLogic.reconnect(connection, this.name);1634 },1635 lostConnection: function (connection) {1636 this.reconnect(connection);1637 },1638 send: function (connection, data) {1639 transportLogic.ajaxSend(connection, data);1640 },1641 stop: function (connection) {1642 // Don't trigger a reconnect after stopping1643 clearReconnectAttemptTimeout(connection);1644 transportLogic.clearReconnectTimeout(connection);1645 if (connection && connection.eventSource) {1646 connection.log("EventSource calling close().");1647 connection.eventSource.close();1648 connection.eventSource = null;1649 delete connection.eventSource;1650 }1651 },1652 abort: function (connection, async) {1653 transportLogic.ajaxAbort(connection, async);1654 }1655 };1656}(window.jQuery, window));1657/* jquery.signalR.transports.foreverFrame.js */1658// Copyright (c) .NET Foundation. All rights reserved.1659// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.1660/*global window:false */1661/// <reference path="jquery.signalR.transports.common.js" />1662(function ($, window, undefined) {1663 var signalR = $.signalR,1664 events = $.signalR.events,1665 changeState = $.signalR.changeState,1666 transportLogic = signalR.transports._logic,1667 createFrame = function () {1668 var frame = window.document.createElement("iframe");1669 frame.setAttribute("style", "position:absolute;top:0;left:0;width:0;height:0;visibility:hidden;");1670 return frame;1671 },1672 // Used to prevent infinite loading icon spins in older versions of ie1673 // We build this object inside a closure so we don't pollute the rest of1674 // the foreverFrame transport with unnecessary functions/utilities.1675 loadPreventer = (function () {1676 var loadingFixIntervalId = null,1677 loadingFixInterval = 1000,1678 attachedTo = 0;1679 return {1680 prevent: function () {1681 // Prevent additional iframe removal procedures from newer browsers1682 if (signalR._.ieVersion <= 8) {1683 // We only ever want to set the interval one time, so on the first attachedTo1684 if (attachedTo === 0) {1685 // Create and destroy iframe every 3 seconds to prevent loading icon, super hacky1686 loadingFixIntervalId = window.setInterval(function () {1687 var tempFrame = createFrame();1688 window.document.body.appendChild(tempFrame);1689 window.document.body.removeChild(tempFrame);1690 tempFrame = null;1691 }, loadingFixInterval);1692 }1693 attachedTo++;1694 }1695 },1696 cancel: function () {1697 // Only clear the interval if there's only one more object that the loadPreventer is attachedTo1698 if (attachedTo === 1) {1699 window.clearInterval(loadingFixIntervalId);1700 }1701 if (attachedTo > 0) {1702 attachedTo--;1703 }1704 }1705 };1706 })();1707 signalR.transports.foreverFrame = {1708 name: "foreverFrame",1709 supportsKeepAlive: function () {1710 return true;1711 },1712 // Added as a value here so we can create tests to verify functionality1713 iframeClearThreshold: 50,1714 start: function (connection, onSuccess, onFailed) {1715 var that = this,1716 frameId = (transportLogic.foreverFrame.count += 1),1717 url,1718 frame = createFrame(),1719 frameLoadHandler = function () {1720 connection.log("Forever frame iframe finished loading and is no longer receiving messages.");1721 if (!onFailed || !onFailed()) {1722 that.reconnect(connection);1723 }1724 };1725 if (window.EventSource) {1726 // If the browser supports SSE, don't use Forever Frame1727 if (onFailed) {1728 connection.log("Forever Frame is not supported by SignalR on browsers with SSE support.");1729 onFailed();1730 }1731 return;1732 }1733 frame.setAttribute("data-signalr-connection-id", connection.id);1734 // Start preventing loading icon1735 // This will only perform work if the loadPreventer is not attached to another connection.1736 loadPreventer.prevent();1737 // Build the url1738 url = transportLogic.getUrl(connection, this.name);1739 url += "&frameId=" + frameId;1740 // add frame to the document prior to setting URL to avoid caching issues.1741 window.document.documentElement.appendChild(frame);1742 connection.log("Binding to iframe's load event.");1743 if (frame.addEventListener) {1744 frame.addEventListener("load", frameLoadHandler, false);1745 } else if (frame.attachEvent) {1746 frame.attachEvent("onload", frameLoadHandler);1747 }1748 frame.src = url;1749 transportLogic.foreverFrame.connections[frameId] = connection;1750 connection.frame = frame;1751 connection.frameId = frameId;1752 if (onSuccess) {1753 connection.onSuccess = function () {1754 connection.log("Iframe transport started.");1755 onSuccess();1756 };1757 }1758 },1759 reconnect: function (connection) {1760 var that = this;1761 // Need to verify connection state and verify before the setTimeout occurs because an application sleep could occur during the setTimeout duration.1762 if (transportLogic.isConnectedOrReconnecting(connection) && transportLogic.verifyLastActive(connection)) {1763 window.setTimeout(function () {1764 // Verify that we're ok to reconnect.1765 if (!transportLogic.verifyLastActive(connection)) {1766 return;1767 }1768 if (connection.frame && transportLogic.ensureReconnectingState(connection)) {1769 var frame = connection.frame,1770 src = transportLogic.getUrl(connection, that.name, true) + "&frameId=" + connection.frameId;1771 connection.log("Updating iframe src to '" + src + "'.");1772 frame.src = src;1773 }1774 }, connection.reconnectDelay);1775 }1776 },1777 lostConnection: function (connection) {1778 this.reconnect(connection);1779 },1780 send: function (connection, data) {1781 transportLogic.ajaxSend(connection, data);1782 },1783 receive: function (connection, data) {1784 var cw,1785 body,1786 response;1787 if (connection.json !== connection._originalJson) {1788 // If there's a custom JSON parser configured then serialize the object1789 // using the original (browser) JSON parser and then deserialize it using1790 // the custom parser (connection._parseResponse does that). This is so we1791 // can easily send the response from the server as "raw" JSON but still1792 // support custom JSON deserialization in the browser.1793 data = connection._originalJson.stringify(data);1794 }1795 response = connection._parseResponse(data);1796 transportLogic.processMessages(connection, response, connection.onSuccess);1797 // Protect against connection stopping from a callback trigger within the processMessages above.1798 if (connection.state === $.signalR.connectionState.connected) {1799 // Delete the script & div elements1800 connection.frameMessageCount = (connection.frameMessageCount || 0) + 1;1801 if (connection.frameMessageCount > signalR.transports.foreverFrame.iframeClearThreshold) {1802 connection.frameMessageCount = 0;1803 cw = connection.frame.contentWindow || connection.frame.contentDocument;1804 if (cw && cw.document && cw.document.body) {1805 body = cw.document.body;1806 // Remove all the child elements from the iframe's body to conserver memory1807 while (body.firstChild) {1808 body.removeChild(body.firstChild);1809 }1810 }1811 }1812 }1813 },1814 stop: function (connection) {1815 var cw = null;1816 // Stop attempting to prevent loading icon1817 loadPreventer.cancel();1818 if (connection.frame) {1819 if (connection.frame.stop) {1820 connection.frame.stop();1821 } else {1822 try {1823 cw = connection.frame.contentWindow || connection.frame.contentDocument;1824 if (cw.document && cw.document.execCommand) {1825 cw.document.execCommand("Stop");1826 }1827 }1828 catch (e) {1829 connection.log("Error occurred when stopping foreverFrame transport. Message = " + e.message + ".");1830 }1831 }1832 // Ensure the iframe is where we left it1833 if (connection.frame.parentNode === window.document.documentElement) {1834 window.document.documentElement.removeChild(connection.frame);1835 }1836 delete transportLogic.foreverFrame.connections[connection.frameId];1837 connection.frame = null;1838 connection.frameId = null;1839 delete connection.frame;1840 delete connection.frameId;1841 delete connection.onSuccess;1842 delete connection.frameMessageCount;1843 connection.log("Stopping forever frame.");1844 }1845 },1846 abort: function (connection, async) {1847 transportLogic.ajaxAbort(connection, async);1848 },1849 getConnection: function (id) {1850 return transportLogic.foreverFrame.connections[id];1851 },1852 started: function (connection) {1853 if (changeState(connection,1854 signalR.connectionState.reconnecting,1855 signalR.connectionState.connected) === true) {1856 $(connection).triggerHandler(events.onReconnect);1857 }1858 }1859 };1860}(window.jQuery, window));1861/* jquery.signalR.transports.longPolling.js */1862// Copyright (c) .NET Foundation. All rights reserved.1863// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.1864/*global window:false */1865/// <reference path="jquery.signalR.transports.common.js" />1866(function ($, window, undefined) {1867 var signalR = $.signalR,1868 events = $.signalR.events,1869 changeState = $.signalR.changeState,1870 isDisconnecting = $.signalR.isDisconnecting,1871 transportLogic = signalR.transports._logic;1872 signalR.transports.longPolling = {1873 name: "longPolling",1874 supportsKeepAlive: function () {1875 return false;1876 },1877 reconnectDelay: 3000,1878 start: function (connection, onSuccess, onFailed) {1879 /// <summary>Starts the long polling connection</summary>1880 /// <param name="connection" type="signalR">The SignalR connection to start</param>1881 var that = this,1882 fireConnect = function () {1883 fireConnect = $.noop;1884 connection.log("LongPolling connected.");1885 if (onSuccess) {1886 onSuccess();1887 } else {1888 connection.log("WARNING! The client received an init message after reconnecting.");1889 }1890 },1891 tryFailConnect = function (error) {1892 if (onFailed(error)) {1893 connection.log("LongPolling failed to connect.");1894 return true;1895 }1896 return false;1897 },1898 privateData = connection._,1899 reconnectErrors = 0,1900 fireReconnected = function (instance) {1901 window.clearTimeout(privateData.reconnectTimeoutId);1902 privateData.reconnectTimeoutId = null;1903 if (changeState(instance,1904 signalR.connectionState.reconnecting,1905 signalR.connectionState.connected) === true) {1906 // Successfully reconnected!1907 instance.log("Raising the reconnect event");1908 $(instance).triggerHandler(events.onReconnect);1909 }1910 },1911 // 1 hour1912 maxFireReconnectedTimeout = 3600000;1913 if (connection.pollXhr) {1914 connection.log("Polling xhr requests already exists, aborting.");1915 connection.stop();1916 }1917 connection.messageId = null;1918 privateData.reconnectTimeoutId = null;1919 privateData.pollTimeoutId = window.setTimeout(function () {1920 (function poll(instance, raiseReconnect) {1921 var messageId = instance.messageId,1922 connect = (messageId === null),1923 reconnecting = !connect,1924 polling = !raiseReconnect,1925 url = transportLogic.getUrl(instance, that.name, reconnecting, polling, true /* use Post for longPolling */),1926 postData = {};1927 if (instance.messageId) {1928 postData.messageId = instance.messageId;1929 }1930 if (instance.groupsToken) {1931 postData.groupsToken = instance.groupsToken;1932 }1933 // If we've disconnected during the time we've tried to re-instantiate the poll then stop.1934 if (isDisconnecting(instance) === true) {1935 return;1936 }1937 connection.log("Opening long polling request to '" + url + "'.");1938 instance.pollXhr = transportLogic.ajax(connection, {1939 xhrFields: {1940 onprogress: function () {1941 transportLogic.markLastMessage(connection);1942 }1943 },1944 url: url,1945 type: "POST",1946 contentType: signalR._.defaultContentType,1947 data: postData,1948 timeout: connection._.pollTimeout,1949 success: function (result) {1950 var minData,1951 delay = 0,1952 data,1953 shouldReconnect;1954 connection.log("Long poll complete.");1955 // Reset our reconnect errors so if we transition into a reconnecting state again we trigger1956 // reconnected quickly1957 reconnectErrors = 0;1958 try {1959 // Remove any keep-alives from the beginning of the result1960 minData = connection._parseResponse(result);1961 }1962 catch (error) {1963 transportLogic.handleParseFailure(instance, result, error, tryFailConnect, instance.pollXhr);1964 return;1965 }1966 // If there's currently a timeout to trigger reconnect, fire it now before processing messages1967 if (privateData.reconnectTimeoutId !== null) {1968 fireReconnected(instance);1969 }1970 if (minData) {1971 data = transportLogic.maximizePersistentResponse(minData);1972 }1973 transportLogic.processMessages(instance, minData, fireConnect);1974 if (data &&1975 $.type(data.LongPollDelay) === "number") {1976 delay = data.LongPollDelay;1977 }1978 if (isDisconnecting(instance) === true) {1979 return;1980 }1981 shouldReconnect = data && data.ShouldReconnect;1982 if (shouldReconnect) {1983 // Transition into the reconnecting state1984 // If this fails then that means that the user transitioned the connection into a invalid state in processMessages.1985 if (!transportLogic.ensureReconnectingState(instance)) {1986 return;1987 }1988 }1989 // We never want to pass a raiseReconnect flag after a successful poll. This is handled via the error function1990 if (delay > 0) {1991 privateData.pollTimeoutId = window.setTimeout(function () {1992 poll(instance, shouldReconnect);1993 }, delay);1994 } else {1995 poll(instance, shouldReconnect);1996 }1997 },1998 error: function (data, textStatus) {1999 var error = signalR._.transportError(signalR.resources.longPollFailed, connection.transport, data, instance.pollXhr);2000 // Stop trying to trigger reconnect, connection is in an error state2001 // If we're not in the reconnect state this will noop2002 window.clearTimeout(privateData.reconnectTimeoutId);2003 privateData.reconnectTimeoutId = null;2004 if (textStatus === "abort") {2005 connection.log("Aborted xhr request.");2006 return;2007 }2008 if (!tryFailConnect(error)) {2009 // Increment our reconnect errors, we assume all errors to be reconnect errors2010 // In the case that it's our first error this will cause Reconnect to be fired2011 // after 1 second due to reconnectErrors being = 1.2012 reconnectErrors++;2013 if (connection.state !== signalR.connectionState.reconnecting) {2014 connection.log("An error occurred using longPolling. Status = " + textStatus + ". Response = " + data.responseText + ".");2015 $(instance).triggerHandler(events.onError, [error]);2016 }2017 // We check the state here to verify that we're not in an invalid state prior to verifying Reconnect.2018 // If we're not in connected or reconnecting then the next ensureReconnectingState check will fail and will return.2019 // Therefore we don't want to change that failure code path.2020 if ((connection.state === signalR.connectionState.connected ||2021 connection.state === signalR.connectionState.reconnecting) &&2022 !transportLogic.verifyLastActive(connection)) {2023 return;2024 }2025 // Transition into the reconnecting state2026 // If this fails then that means that the user transitioned the connection into the disconnected or connecting state within the above error handler trigger.2027 if (!transportLogic.ensureReconnectingState(instance)) {2028 return;2029 }2030 // Call poll with the raiseReconnect flag as true after the reconnect delay2031 privateData.pollTimeoutId = window.setTimeout(function () {2032 poll(instance, true);2033 }, that.reconnectDelay);2034 }2035 }2036 });2037 // This will only ever pass after an error has occurred via the poll ajax procedure.2038 if (reconnecting && raiseReconnect === true) {2039 // We wait to reconnect depending on how many times we've failed to reconnect.2040 // This is essentially a heuristic that will exponentially increase in wait time before2041 // triggering reconnected. This depends on the "error" handler of Poll to cancel this2042 // timeout if it triggers before the Reconnected event fires.2043 // The Math.min at the end is to ensure that the reconnect timeout does not overflow.2044 privateData.reconnectTimeoutId = window.setTimeout(function () { fireReconnected(instance); }, Math.min(1000 * (Math.pow(2, reconnectErrors) - 1), maxFireReconnectedTimeout));2045 }2046 }(connection));2047 }, 250); // Have to delay initial poll so Chrome doesn't show loader spinner in tab2048 },2049 lostConnection: function (connection) {2050 if (connection.pollXhr) {2051 connection.pollXhr.abort("lostConnection");2052 }2053 },2054 send: function (connection, data) {2055 transportLogic.ajaxSend(connection, data);2056 },2057 stop: function (connection) {2058 /// <summary>Stops the long polling connection</summary>2059 /// <param name="connection" type="signalR">The SignalR connection to stop</param>2060 window.clearTimeout(connection._.pollTimeoutId);2061 window.clearTimeout(connection._.reconnectTimeoutId);2062 delete connection._.pollTimeoutId;2063 delete connection._.reconnectTimeoutId;2064 if (connection.pollXhr) {2065 connection.pollXhr.abort();2066 connection.pollXhr = null;2067 delete connection.pollXhr;2068 }2069 },2070 abort: function (connection, async) {2071 transportLogic.ajaxAbort(connection, async);2072 }2073 };2074}(window.jQuery, window));2075/* jquery.signalR.hubs.js */2076// Copyright (c) .NET Foundation. All rights reserved.2077// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.2078/*global window:false */2079/// <reference path="jquery.signalR.core.js" />2080(function ($, window, undefined) {2081 var eventNamespace = ".hubProxy",2082 signalR = $.signalR;2083 function makeEventName(event) {2084 return event + eventNamespace;2085 }2086 // Equivalent to Array.prototype.map2087 function map(arr, fun, thisp) {2088 var i,2089 length = arr.length,2090 result = [];2091 for (i = 0; i < length; i += 1) {2092 if (arr.hasOwnProperty(i)) {2093 result[i] = fun.call(thisp, arr[i], i, arr);2094 }2095 }2096 return result;2097 }2098 function getArgValue(a) {2099 return $.isFunction(a) ? null : ($.type(a) === "undefined" ? null : a);2100 }2101 function hasMembers(obj) {2102 for (var key in obj) {2103 // If we have any properties in our callback map then we have callbacks and can exit the loop via return2104 if (obj.hasOwnProperty(key)) {2105 return true;2106 }2107 }2108 return false;2109 }2110 function clearInvocationCallbacks(connection, error) {2111 /// <param name="connection" type="hubConnection" />2112 var callbacks = connection._.invocationCallbacks,2113 callback;2114 if (hasMembers(callbacks)) {2115 connection.log("Clearing hub invocation callbacks with error: " + error + ".");2116 }2117 // Reset the callback cache now as we have a local var referencing it2118 connection._.invocationCallbackId = 0;2119 delete connection._.invocationCallbacks;2120 connection._.invocationCallbacks = {};2121 // Loop over the callbacks and invoke them.2122 // We do this using a local var reference and *after* we've cleared the cache2123 // so that if a fail callback itself tries to invoke another method we don't2124 // end up with its callback in the list we're looping over.2125 for (var callbackId in callbacks) {2126 callback = callbacks[callbackId];2127 callback.method.call(callback.scope, { E: error });2128 }2129 }2130 // hubProxy2131 function hubProxy(hubConnection, hubName) {2132 /// <summary>2133 /// Creates a new proxy object for the given hub connection that can be used to invoke2134 /// methods on server hubs and handle client method invocation requests from the server.2135 /// </summary>2136 return new hubProxy.fn.init(hubConnection, hubName);2137 }2138 hubProxy.fn = hubProxy.prototype = {2139 init: function (connection, hubName) {2140 this.state = {};2141 this.connection = connection;2142 this.hubName = hubName;2143 this._ = {2144 callbackMap: {}2145 };2146 },2147 constructor: hubProxy,2148 hasSubscriptions: function () {2149 return hasMembers(this._.callbackMap);2150 },2151 on: function (eventName, callback) {2152 /// <summary>Wires up a callback to be invoked when a invocation request is received from the server hub.</summary>2153 /// <param name="eventName" type="String">The name of the hub event to register the callback for.</param>2154 /// <param name="callback" type="Function">The callback to be invoked.</param>2155 var that = this,2156 callbackMap = that._.callbackMap;2157 // Normalize the event name to lowercase2158 eventName = eventName.toLowerCase();2159 // If there is not an event registered for this callback yet we want to create its event space in the callback map.2160 if (!callbackMap[eventName]) {2161 callbackMap[eventName] = {};2162 }2163 // Map the callback to our encompassed function2164 callbackMap[eventName][callback] = function (e, data) {2165 callback.apply(that, data);2166 };2167 $(that).bind(makeEventName(eventName), callbackMap[eventName][callback]);2168 return that;2169 },2170 off: function (eventName, callback) {2171 /// <summary>Removes the callback invocation request from the server hub for the given event name.</summary>2172 /// <param name="eventName" type="String">The name of the hub event to unregister the callback for.</param>2173 /// <param name="callback" type="Function">The callback to be invoked.</param>2174 var that = this,2175 callbackMap = that._.callbackMap,2176 callbackSpace;2177 // Normalize the event name to lowercase2178 eventName = eventName.toLowerCase();2179 callbackSpace = callbackMap[eventName];2180 // Verify that there is an event space to unbind2181 if (callbackSpace) {2182 // Only unbind if there's an event bound with eventName and a callback with the specified callback2183 if (callbackSpace[callback]) {2184 $(that).unbind(makeEventName(eventName), callbackSpace[callback]);2185 // Remove the callback from the callback map2186 delete callbackSpace[callback];2187 // Check if there are any members left on the event, if not we need to destroy it.2188 if (!hasMembers(callbackSpace)) {2189 delete callbackMap[eventName];2190 }2191 } else if (!callback) { // Check if we're removing the whole event and we didn't error because of an invalid callback2192 $(that).unbind(makeEventName(eventName));2193 delete callbackMap[eventName];2194 }2195 }2196 return that;2197 },2198 invoke: function (methodName) {2199 /// <summary>Invokes a server hub method with the given arguments.</summary>2200 /// <param name="methodName" type="String">The name of the server hub method.</param>2201 var that = this,2202 connection = that.connection,2203 args = $.makeArray(arguments).slice(1),2204 argValues = map(args, getArgValue),2205 data = { H: that.hubName, M: methodName, A: argValues, I: connection._.invocationCallbackId },2206 d = $.Deferred(),2207 callback = function (minResult) {2208 var result = that._maximizeHubResponse(minResult),2209 source,2210 error;2211 // Update the hub state2212 $.extend(that.state, result.State);2213 if (result.Progress) {2214 if (d.notifyWith) {2215 // Progress is only supported in jQuery 1.7+2216 d.notifyWith(that, [result.Progress.Data]);2217 } else if(!connection._.progressjQueryVersionLogged) {2218 connection.log("A hub method invocation progress update was received but the version of jQuery in use (" + $.prototype.jquery + ") does not support progress updates. Upgrade to jQuery 1.7+ to receive progress notifications.");2219 connection._.progressjQueryVersionLogged = true;2220 }2221 } else if (result.Error) {2222 // Server hub method threw an exception, log it & reject the deferred2223 if (result.StackTrace) {2224 connection.log(result.Error + "\n" + result.StackTrace + ".");2225 }2226 // result.ErrorData is only set if a HubException was thrown2227 source = result.IsHubException ? "HubException" : "Exception";2228 error = signalR._.error(result.Error, source);2229 error.data = result.ErrorData;2230 connection.log(that.hubName + "." + methodName + " failed to execute. Error: " + error.message);2231 d.rejectWith(that, [error]);2232 } else {2233 // Server invocation succeeded, resolve the deferred2234 connection.log("Invoked " + that.hubName + "." + methodName);2235 d.resolveWith(that, [result.Result]);2236 }2237 };2238 connection._.invocationCallbacks[connection._.invocationCallbackId.toString()] = { scope: that, method: callback };2239 connection._.invocationCallbackId += 1;2240 if (!$.isEmptyObject(that.state)) {2241 data.S = that.state;2242 }2243 connection.log("Invoking " + that.hubName + "." + methodName);2244 connection.send(data);2245 return d.promise();2246 },2247 _maximizeHubResponse: function (minHubResponse) {2248 return {2249 State: minHubResponse.S,2250 Result: minHubResponse.R,2251 Progress: minHubResponse.P ? {2252 Id: minHubResponse.P.I,2253 Data: minHubResponse.P.D2254 } : null,2255 Id: minHubResponse.I,2256 IsHubException: minHubResponse.H,2257 Error: minHubResponse.E,2258 StackTrace: minHubResponse.T,2259 ErrorData: minHubResponse.D2260 };2261 }2262 };2263 hubProxy.fn.init.prototype = hubProxy.fn;2264 // hubConnection2265 function hubConnection(url, options) {2266 /// <summary>Creates a new hub connection.</summary>2267 /// <param name="url" type="String">[Optional] The hub route url, defaults to "/signalr".</param>2268 /// <param name="options" type="Object">[Optional] Settings to use when creating the hubConnection.</param>2269 var settings = {2270 qs: null,2271 logging: false,2272 useDefaultPath: true2273 };2274 $.extend(settings, options);2275 if (!url || settings.useDefaultPath) {2276 url = (url || "") + "/signalr";2277 }2278 return new hubConnection.fn.init(url, settings);2279 }...

Full Screen

Full Screen

jquery.signalR-2.2.1.js

Source:jquery.signalR-2.2.1.js Github

copy

Full Screen

...835 // Check if the keep alive has completely timed out836 if (timeElapsed >= keepAliveData.timeout) {837 connection.log("Keep alive timed out. Notifying transport that connection has been lost.");838 // Notify transport that the connection has been lost839 connection.transport.lostConnection(connection);840 } else if (timeElapsed >= keepAliveData.timeoutWarning) {841 // This is to assure that the user only gets a single warning842 if (!keepAliveData.userNotified) {843 connection.log("Keep alive has been missed, connection may be dead/slow.");844 $(connection).triggerHandler(events.onConnectionSlow);845 keepAliveData.userNotified = true;846 }847 } else {848 keepAliveData.userNotified = false;849 }850 }851 }852 function getAjaxUrl(connection, path) {853 var url = connection.url + path;854 if (connection.transport) {855 url += "?transport=" + connection.transport.name;856 }857 return transportLogic.prepareQueryString(connection, url);858 }859 function InitHandler(connection) {860 this.connection = connection;861 this.startRequested = false;862 this.startCompleted = false;863 this.connectionStopped = false;864 }865 InitHandler.prototype = {866 start: function (transport, onSuccess, onFallback) {867 var that = this,868 connection = that.connection,869 failCalled = false;870 if (that.startRequested || that.connectionStopped) {871 connection.log("WARNING! " + transport.name + " transport cannot be started. Initialization ongoing or completed.");872 return;873 }874 connection.log(transport.name + " transport starting.");875 transport.start(connection, function () {876 if (!failCalled) {877 that.initReceived(transport, onSuccess);878 }879 }, function (error) {880 // Don't allow the same transport to cause onFallback to be called twice881 if (!failCalled) {882 failCalled = true;883 that.transportFailed(transport, error, onFallback);884 }885 // Returns true if the transport should stop;886 // false if it should attempt to reconnect887 return !that.startCompleted || that.connectionStopped;888 });889 that.transportTimeoutHandle = window.setTimeout(function () {890 if (!failCalled) {891 failCalled = true;892 connection.log(transport.name + " transport timed out when trying to connect.");893 that.transportFailed(transport, undefined, onFallback);894 }895 }, connection._.totalTransportConnectTimeout);896 },897 stop: function () {898 this.connectionStopped = true;899 window.clearTimeout(this.transportTimeoutHandle);900 signalR.transports._logic.tryAbortStartRequest(this.connection);901 },902 initReceived: function (transport, onSuccess) {903 var that = this,904 connection = that.connection;905 if (that.startRequested) {906 connection.log("WARNING! The client received multiple init messages.");907 return;908 }909 if (that.connectionStopped) {910 return;911 }912 that.startRequested = true;913 window.clearTimeout(that.transportTimeoutHandle);914 connection.log(transport.name + " transport connected. Initiating start request.");915 signalR.transports._logic.ajaxStart(connection, function () {916 that.startCompleted = true;917 onSuccess();918 });919 },920 transportFailed: function (transport, error, onFallback) {921 var connection = this.connection,922 deferred = connection._deferral,923 wrappedError;924 if (this.connectionStopped) {925 return;926 }927 window.clearTimeout(this.transportTimeoutHandle);928 if (!this.startRequested) {929 transport.stop(connection);930 connection.log(transport.name + " transport failed to connect. Attempting to fall back.");931 onFallback();932 } else if (!this.startCompleted) {933 // Do not attempt to fall back if a start request is ongoing during a transport failure.934 // Instead, trigger an error and stop the connection.935 wrappedError = signalR._.error(signalR.resources.errorDuringStartRequest, error);936 connection.log(transport.name + " transport failed during the start request. Stopping the connection.");937 $(connection).triggerHandler(events.onError, [wrappedError]);938 if (deferred) {939 deferred.reject(wrappedError);940 }941 connection.stop();942 } else {943 // The start request has completed, but the connection has not stopped.944 // No need to do anything here. The transport should attempt its normal reconnect logic.945 }946 }947 };948 transportLogic = signalR.transports._logic = {949 ajax: function (connection, options) {950 return $.ajax(951 $.extend(/*deep copy*/ true, {}, $.signalR.ajaxDefaults, {952 type: "GET",953 data: {},954 xhrFields: { withCredentials: connection.withCredentials },955 contentType: connection.contentType,956 dataType: connection.ajaxDataType957 }, options));958 },959 pingServer: function (connection) {960 /// <summary>Pings the server</summary>961 /// <param name="connection" type="signalr">Connection associated with the server ping</param>962 /// <returns type="signalR" />963 var url,964 xhr,965 deferral = $.Deferred();966 if (connection.transport) {967 url = connection.url + "/ping";968 url = transportLogic.addQs(url, connection.qs);969 xhr = transportLogic.ajax(connection, {970 url: url,971 success: function (result) {972 var data;973 try {974 data = connection._parseResponse(result);975 }976 catch (error) {977 deferral.reject(978 signalR._.transportError(979 signalR.resources.pingServerFailedParse,980 connection.transport,981 error,982 xhr983 )984 );985 connection.stop();986 return;987 }988 if (data.Response === "pong") {989 deferral.resolve();990 }991 else {992 deferral.reject(993 signalR._.transportError(994 signalR._.format(signalR.resources.pingServerFailedInvalidResponse, result),995 connection.transport,996 null /* error */,997 xhr998 )999 );1000 }1001 },1002 error: function (error) {1003 if (error.status === 401 || error.status === 403) {1004 deferral.reject(1005 signalR._.transportError(1006 signalR._.format(signalR.resources.pingServerFailedStatusCode, error.status),1007 connection.transport,1008 error,1009 xhr1010 )1011 );1012 connection.stop();1013 }1014 else {1015 deferral.reject(1016 signalR._.transportError(1017 signalR.resources.pingServerFailed,1018 connection.transport,1019 error,1020 xhr1021 )1022 );1023 }1024 }1025 });1026 }1027 else {1028 deferral.reject(1029 signalR._.transportError(1030 signalR.resources.noConnectionTransport,1031 connection.transport1032 )1033 );1034 }1035 return deferral.promise();1036 },1037 prepareQueryString: function (connection, url) {1038 var preparedUrl;1039 // Use addQs to start since it handles the ?/& prefix for us1040 preparedUrl = transportLogic.addQs(url, "clientProtocol=" + connection.clientProtocol);1041 // Add the user-specified query string params if any1042 preparedUrl = transportLogic.addQs(preparedUrl, connection.qs);1043 if (connection.token) {1044 preparedUrl += "&connectionToken=" + window.encodeURIComponent(connection.token);1045 }1046 if (connection.data) {1047 preparedUrl += "&connectionData=" + window.encodeURIComponent(connection.data);1048 }1049 return preparedUrl;1050 },1051 addQs: function (url, qs) {1052 var appender = url.indexOf("?") !== -1 ? "&" : "?",1053 firstChar;1054 if (!qs) {1055 return url;1056 }1057 if (typeof (qs) === "object") {1058 return url + appender + $.param(qs);1059 }1060 if (typeof (qs) === "string") {1061 firstChar = qs.charAt(0);1062 if (firstChar === "?" || firstChar === "&") {1063 appender = "";1064 }1065 return url + appender + qs;1066 }1067 throw new Error("Query string property must be either a string or object.");1068 },1069 // BUG #2953: The url needs to be same otherwise it will cause a memory leak1070 getUrl: function (connection, transport, reconnecting, poll, ajaxPost) {1071 /// <summary>Gets the url for making a GET based connect request</summary>1072 var baseUrl = transport === "webSockets" ? "" : connection.baseUrl,1073 url = baseUrl + connection.appRelativeUrl,1074 qs = "transport=" + transport;1075 if (!ajaxPost && connection.groupsToken) {1076 qs += "&groupsToken=" + window.encodeURIComponent(connection.groupsToken);1077 }1078 if (!reconnecting) {1079 url += "/connect";1080 } else {1081 if (poll) {1082 // longPolling transport specific1083 url += "/poll";1084 } else {1085 url += "/reconnect";1086 }1087 if (!ajaxPost && connection.messageId) {1088 qs += "&messageId=" + window.encodeURIComponent(connection.messageId);1089 }1090 }1091 url += "?" + qs;1092 url = transportLogic.prepareQueryString(connection, url);1093 if (!ajaxPost) {1094 url += "&tid=" + Math.floor(Math.random() * 11);1095 }1096 return url;1097 },1098 maximizePersistentResponse: function (minPersistentResponse) {1099 return {1100 MessageId: minPersistentResponse.C,1101 Messages: minPersistentResponse.M,1102 Initialized: typeof (minPersistentResponse.S) !== "undefined" ? true : false,1103 ShouldReconnect: typeof (minPersistentResponse.T) !== "undefined" ? true : false,1104 LongPollDelay: minPersistentResponse.L,1105 GroupsToken: minPersistentResponse.G1106 };1107 },1108 updateGroups: function (connection, groupsToken) {1109 if (groupsToken) {1110 connection.groupsToken = groupsToken;1111 }1112 },1113 stringifySend: function (connection, message) {1114 if (typeof (message) === "string" || typeof (message) === "undefined" || message === null) {1115 return message;1116 }1117 return connection.json.stringify(message);1118 },1119 ajaxSend: function (connection, data) {1120 var payload = transportLogic.stringifySend(connection, data),1121 url = getAjaxUrl(connection, "/send"),1122 xhr,1123 onFail = function (error, connection) {1124 $(connection).triggerHandler(events.onError, [signalR._.transportError(signalR.resources.sendFailed, connection.transport, error, xhr), data]);1125 };1126 xhr = transportLogic.ajax(connection, {1127 url: url,1128 type: connection.ajaxDataType === "jsonp" ? "GET" : "POST",1129 contentType: signalR._.defaultContentType,1130 data: {1131 data: payload1132 },1133 success: function (result) {1134 var res;1135 if (result) {1136 try {1137 res = connection._parseResponse(result);1138 }1139 catch (error) {1140 onFail(error, connection);1141 connection.stop();1142 return;1143 }1144 transportLogic.triggerReceived(connection, res);1145 }1146 },1147 error: function (error, textStatus) {1148 if (textStatus === "abort" || textStatus === "parsererror") {1149 // The parsererror happens for sends that don't return any data, and hence1150 // don't write the jsonp callback to the response. This is harder to fix on the server1151 // so just hack around it on the client for now.1152 return;1153 }1154 onFail(error, connection);1155 }1156 });1157 return xhr;1158 },1159 ajaxAbort: function (connection, async) {1160 if (typeof (connection.transport) === "undefined") {1161 return;1162 }1163 // Async by default unless explicitly overidden1164 async = typeof async === "undefined" ? true : async;1165 var url = getAjaxUrl(connection, "/abort");1166 transportLogic.ajax(connection, {1167 url: url,1168 async: async,1169 timeout: 1000,1170 type: "POST"1171 });1172 connection.log("Fired ajax abort async = " + async + ".");1173 },1174 ajaxStart: function (connection, onSuccess) {1175 var rejectDeferred = function (error) {1176 var deferred = connection._deferral;1177 if (deferred) {1178 deferred.reject(error);1179 }1180 },1181 triggerStartError = function (error) {1182 connection.log("The start request failed. Stopping the connection.");1183 $(connection).triggerHandler(events.onError, [error]);1184 rejectDeferred(error);1185 connection.stop();1186 };1187 connection._.startRequest = transportLogic.ajax(connection, {1188 url: getAjaxUrl(connection, "/start"),1189 success: function (result, statusText, xhr) {1190 var data;1191 try {1192 data = connection._parseResponse(result);1193 } catch (error) {1194 triggerStartError(signalR._.error(1195 signalR._.format(signalR.resources.errorParsingStartResponse, result),1196 error, xhr));1197 return;1198 }1199 if (data.Response === "started") {1200 onSuccess();1201 } else {1202 triggerStartError(signalR._.error(1203 signalR._.format(signalR.resources.invalidStartResponse, result),1204 null /* error */, xhr));1205 }1206 },1207 error: function (xhr, statusText, error) {1208 if (statusText !== startAbortText) {1209 triggerStartError(signalR._.error(1210 signalR.resources.errorDuringStartRequest,1211 error, xhr));1212 } else {1213 // Stop has been called, no need to trigger the error handler1214 // or stop the connection again with onStartError1215 connection.log("The start request aborted because connection.stop() was called.");1216 rejectDeferred(signalR._.error(1217 signalR.resources.stoppedDuringStartRequest,1218 null /* error */, xhr));1219 }1220 }1221 });1222 },1223 tryAbortStartRequest: function (connection) {1224 if (connection._.startRequest) {1225 // If the start request has already completed this will noop.1226 connection._.startRequest.abort(startAbortText);1227 delete connection._.startRequest;1228 }1229 },1230 tryInitialize: function (connection, persistentResponse, onInitialized) {1231 if (persistentResponse.Initialized && onInitialized) {1232 onInitialized();1233 } else if (persistentResponse.Initialized) {1234 connection.log("WARNING! The client received an init message after reconnecting.");1235 }1236 },1237 triggerReceived: function (connection, data) {1238 if (!connection._.connectingMessageBuffer.tryBuffer(data)) {1239 $(connection).triggerHandler(events.onReceived, [data]);1240 }1241 },1242 processMessages: function (connection, minData, onInitialized) {1243 var data;1244 // Update the last message time stamp1245 transportLogic.markLastMessage(connection);1246 if (minData) {1247 data = transportLogic.maximizePersistentResponse(minData);1248 transportLogic.updateGroups(connection, data.GroupsToken);1249 if (data.MessageId) {1250 connection.messageId = data.MessageId;1251 }1252 if (data.Messages) {1253 $.each(data.Messages, function (index, message) {1254 transportLogic.triggerReceived(connection, message);1255 });1256 transportLogic.tryInitialize(connection, data, onInitialized);1257 }1258 }1259 },1260 monitorKeepAlive: function (connection) {1261 var keepAliveData = connection._.keepAliveData;1262 // If we haven't initiated the keep alive timeouts then we need to1263 if (!keepAliveData.monitoring) {1264 keepAliveData.monitoring = true;1265 transportLogic.markLastMessage(connection);1266 // Save the function so we can unbind it on stop1267 connection._.keepAliveData.reconnectKeepAliveUpdate = function () {1268 // Mark a new message so that keep alive doesn't time out connections1269 transportLogic.markLastMessage(connection);1270 };1271 // Update Keep alive on reconnect1272 $(connection).bind(events.onReconnect, connection._.keepAliveData.reconnectKeepAliveUpdate);1273 connection.log("Now monitoring keep alive with a warning timeout of " + keepAliveData.timeoutWarning + ", keep alive timeout of " + keepAliveData.timeout + " and disconnecting timeout of " + connection.disconnectTimeout);1274 } else {1275 connection.log("Tried to monitor keep alive but it's already being monitored.");1276 }1277 },1278 stopMonitoringKeepAlive: function (connection) {1279 var keepAliveData = connection._.keepAliveData;1280 // Only attempt to stop the keep alive monitoring if its being monitored1281 if (keepAliveData.monitoring) {1282 // Stop monitoring1283 keepAliveData.monitoring = false;1284 // Remove the updateKeepAlive function from the reconnect event1285 $(connection).unbind(events.onReconnect, connection._.keepAliveData.reconnectKeepAliveUpdate);1286 // Clear all the keep alive data1287 connection._.keepAliveData = {};1288 connection.log("Stopping the monitoring of the keep alive.");1289 }1290 },1291 startHeartbeat: function (connection) {1292 connection._.lastActiveAt = new Date().getTime();1293 beat(connection);1294 },1295 markLastMessage: function (connection) {1296 connection._.lastMessageAt = new Date().getTime();1297 },1298 markActive: function (connection) {1299 if (transportLogic.verifyLastActive(connection)) {1300 connection._.lastActiveAt = new Date().getTime();1301 return true;1302 }1303 return false;1304 },1305 isConnectedOrReconnecting: function (connection) {1306 return connection.state === signalR.connectionState.connected ||1307 connection.state === signalR.connectionState.reconnecting;1308 },1309 ensureReconnectingState: function (connection) {1310 if (changeState(connection,1311 signalR.connectionState.connected,1312 signalR.connectionState.reconnecting) === true) {1313 $(connection).triggerHandler(events.onReconnecting);1314 }1315 return connection.state === signalR.connectionState.reconnecting;1316 },1317 clearReconnectTimeout: function (connection) {1318 if (connection && connection._.reconnectTimeout) {1319 window.clearTimeout(connection._.reconnectTimeout);1320 delete connection._.reconnectTimeout;1321 }1322 },1323 verifyLastActive: function (connection) {1324 if (new Date().getTime() - connection._.lastActiveAt >= connection.reconnectWindow) {1325 var message = signalR._.format(signalR.resources.reconnectWindowTimeout, new Date(connection._.lastActiveAt), connection.reconnectWindow);1326 connection.log(message);1327 $(connection).triggerHandler(events.onError, [signalR._.error(message, /* source */ "TimeoutException")]);1328 connection.stop(/* async */ false, /* notifyServer */ false);1329 return false;1330 }1331 return true;1332 },1333 reconnect: function (connection, transportName) {1334 var transport = signalR.transports[transportName];1335 // We should only set a reconnectTimeout if we are currently connected1336 // and a reconnectTimeout isn't already set.1337 if (transportLogic.isConnectedOrReconnecting(connection) && !connection._.reconnectTimeout) {1338 // Need to verify before the setTimeout occurs because an application sleep could occur during the setTimeout duration.1339 if (!transportLogic.verifyLastActive(connection)) {1340 return;1341 }1342 connection._.reconnectTimeout = window.setTimeout(function () {1343 if (!transportLogic.verifyLastActive(connection)) {1344 return;1345 }1346 transport.stop(connection);1347 if (transportLogic.ensureReconnectingState(connection)) {1348 connection.log(transportName + " reconnecting.");1349 transport.start(connection);1350 }1351 }, connection.reconnectDelay);1352 }1353 },1354 handleParseFailure: function (connection, result, error, onFailed, context) {1355 var wrappedError = signalR._.transportError(1356 signalR._.format(signalR.resources.parseFailed, result),1357 connection.transport,1358 error,1359 context);1360 // If we're in the initialization phase trigger onFailed, otherwise stop the connection.1361 if (onFailed && onFailed(wrappedError)) {1362 connection.log("Failed to parse server response while attempting to connect.");1363 } else {1364 $(connection).triggerHandler(events.onError, [wrappedError]);1365 connection.stop();1366 }1367 },1368 initHandler: function (connection) {1369 return new InitHandler(connection);1370 },1371 foreverFrame: {1372 count: 0,1373 connections: {}1374 }1375 };1376}(window.jQuery, window));1377/* jquery.signalR.transports.webSockets.js */1378// Copyright (c) .NET Foundation. All rights reserved.1379// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.1380/*global window:false */1381/// <reference path="jquery.signalR.transports.common.js" />1382(function ($, window, undefined) {1383 var signalR = $.signalR,1384 events = $.signalR.events,1385 changeState = $.signalR.changeState,1386 transportLogic = signalR.transports._logic;1387 signalR.transports.webSockets = {1388 name: "webSockets",1389 supportsKeepAlive: function () {1390 return true;1391 },1392 send: function (connection, data) {1393 var payload = transportLogic.stringifySend(connection, data);1394 try {1395 connection.socket.send(payload);1396 } catch (ex) {1397 $(connection).triggerHandler(events.onError,1398 [signalR._.transportError(1399 signalR.resources.webSocketsInvalidState,1400 connection.transport,1401 ex,1402 connection.socket1403 ),1404 data]);1405 }1406 },1407 start: function (connection, onSuccess, onFailed) {1408 var url,1409 opened = false,1410 that = this,1411 reconnecting = !onSuccess,1412 $connection = $(connection);1413 if (!window.WebSocket) {1414 onFailed();1415 return;1416 }1417 if (!connection.socket) {1418 if (connection.webSocketServerUrl) {1419 url = connection.webSocketServerUrl;1420 } else {1421 url = connection.wsProtocol + connection.host;1422 }1423 url += transportLogic.getUrl(connection, this.name, reconnecting);1424 connection.log("Connecting to websocket endpoint '" + url + "'.");1425 connection.socket = new window.WebSocket(url);1426 connection.socket.onopen = function () {1427 opened = true;1428 connection.log("Websocket opened.");1429 transportLogic.clearReconnectTimeout(connection);1430 if (changeState(connection,1431 signalR.connectionState.reconnecting,1432 signalR.connectionState.connected) === true) {1433 $connection.triggerHandler(events.onReconnect);1434 }1435 };1436 connection.socket.onclose = function (event) {1437 var error;1438 // Only handle a socket close if the close is from the current socket.1439 // Sometimes on disconnect the server will push down an onclose event1440 // to an expired socket.1441 if (this === connection.socket) {1442 if (opened && typeof event.wasClean !== "undefined" && event.wasClean === false) {1443 // Ideally this would use the websocket.onerror handler (rather than checking wasClean in onclose) but1444 // I found in some circumstances Chrome won't call onerror. This implementation seems to work on all browsers.1445 error = signalR._.transportError(1446 signalR.resources.webSocketClosed,1447 connection.transport,1448 event);1449 connection.log("Unclean disconnect from websocket: " + (event.reason || "[no reason given]."));1450 } else {1451 connection.log("Websocket closed.");1452 }1453 if (!onFailed || !onFailed(error)) {1454 if (error) {1455 $(connection).triggerHandler(events.onError, [error]);1456 }1457 that.reconnect(connection);1458 }1459 }1460 };1461 connection.socket.onmessage = function (event) {1462 var data;1463 try {1464 data = connection._parseResponse(event.data);1465 }1466 catch (error) {1467 transportLogic.handleParseFailure(connection, event.data, error, onFailed, event);1468 return;1469 }1470 if (data) {1471 // data.M is PersistentResponse.Messages1472 if ($.isEmptyObject(data) || data.M) {1473 transportLogic.processMessages(connection, data, onSuccess);1474 } else {1475 // For websockets we need to trigger onReceived1476 // for callbacks to outgoing hub calls.1477 transportLogic.triggerReceived(connection, data);1478 }1479 }1480 };1481 }1482 },1483 reconnect: function (connection) {1484 transportLogic.reconnect(connection, this.name);1485 },1486 lostConnection: function (connection) {1487 this.reconnect(connection);1488 },1489 stop: function (connection) {1490 // Don't trigger a reconnect after stopping1491 transportLogic.clearReconnectTimeout(connection);1492 if (connection.socket) {1493 connection.log("Closing the Websocket.");1494 connection.socket.close();1495 connection.socket = null;1496 }1497 },1498 abort: function (connection, async) {1499 transportLogic.ajaxAbort(connection, async);1500 }1501 };1502}(window.jQuery, window));1503/* jquery.signalR.transports.serverSentEvents.js */1504// Copyright (c) .NET Foundation. All rights reserved.1505// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.1506/*global window:false */1507/// <reference path="jquery.signalR.transports.common.js" />1508(function ($, window, undefined) {1509 var signalR = $.signalR,1510 events = $.signalR.events,1511 changeState = $.signalR.changeState,1512 transportLogic = signalR.transports._logic,1513 clearReconnectAttemptTimeout = function (connection) {1514 window.clearTimeout(connection._.reconnectAttemptTimeoutHandle);1515 delete connection._.reconnectAttemptTimeoutHandle;1516 };1517 signalR.transports.serverSentEvents = {1518 name: "serverSentEvents",1519 supportsKeepAlive: function () {1520 return true;1521 },1522 timeOut: 3000,1523 start: function (connection, onSuccess, onFailed) {1524 var that = this,1525 opened = false,1526 $connection = $(connection),1527 reconnecting = !onSuccess,1528 url;1529 if (connection.eventSource) {1530 connection.log("The connection already has an event source. Stopping it.");1531 connection.stop();1532 }1533 if (!window.EventSource) {1534 if (onFailed) {1535 connection.log("This browser doesn't support SSE.");1536 onFailed();1537 }1538 return;1539 }1540 url = transportLogic.getUrl(connection, this.name, reconnecting);1541 try {1542 connection.log("Attempting to connect to SSE endpoint '" + url + "'.");1543 connection.eventSource = new window.EventSource(url, { withCredentials: connection.withCredentials });1544 }1545 catch (e) {1546 connection.log("EventSource failed trying to connect with error " + e.Message + ".");1547 if (onFailed) {1548 // The connection failed, call the failed callback1549 onFailed();1550 } else {1551 $connection.triggerHandler(events.onError, [signalR._.transportError(signalR.resources.eventSourceFailedToConnect, connection.transport, e)]);1552 if (reconnecting) {1553 // If we were reconnecting, rather than doing initial connect, then try reconnect again1554 that.reconnect(connection);1555 }1556 }1557 return;1558 }1559 if (reconnecting) {1560 connection._.reconnectAttemptTimeoutHandle = window.setTimeout(function () {1561 if (opened === false) {1562 // If we're reconnecting and the event source is attempting to connect,1563 // don't keep retrying. This causes duplicate connections to spawn.1564 if (connection.eventSource.readyState !== window.EventSource.OPEN) {1565 // If we were reconnecting, rather than doing initial connect, then try reconnect again1566 that.reconnect(connection);1567 }1568 }1569 },1570 that.timeOut);1571 }1572 connection.eventSource.addEventListener("open", function (e) {1573 connection.log("EventSource connected.");1574 clearReconnectAttemptTimeout(connection);1575 transportLogic.clearReconnectTimeout(connection);1576 if (opened === false) {1577 opened = true;1578 if (changeState(connection,1579 signalR.connectionState.reconnecting,1580 signalR.connectionState.connected) === true) {1581 $connection.triggerHandler(events.onReconnect);1582 }1583 }1584 }, false);1585 connection.eventSource.addEventListener("message", function (e) {1586 var res;1587 // process messages1588 if (e.data === "initialized") {1589 return;1590 }1591 try {1592 res = connection._parseResponse(e.data);1593 }1594 catch (error) {1595 transportLogic.handleParseFailure(connection, e.data, error, onFailed, e);1596 return;1597 }1598 transportLogic.processMessages(connection, res, onSuccess);1599 }, false);1600 connection.eventSource.addEventListener("error", function (e) {1601 var error = signalR._.transportError(1602 signalR.resources.eventSourceError,1603 connection.transport,1604 e);1605 // Only handle an error if the error is from the current Event Source.1606 // Sometimes on disconnect the server will push down an error event1607 // to an expired Event Source.1608 if (this !== connection.eventSource) {1609 return;1610 }1611 if (onFailed && onFailed(error)) {1612 return;1613 }1614 connection.log("EventSource readyState: " + connection.eventSource.readyState + ".");1615 if (e.eventPhase === window.EventSource.CLOSED) {1616 // We don't use the EventSource's native reconnect function as it1617 // doesn't allow us to change the URL when reconnecting. We need1618 // to change the URL to not include the /connect suffix, and pass1619 // the last message id we received.1620 connection.log("EventSource reconnecting due to the server connection ending.");1621 that.reconnect(connection);1622 } else {1623 // connection error1624 connection.log("EventSource error.");1625 $connection.triggerHandler(events.onError, [error]);1626 }1627 }, false);1628 },1629 reconnect: function (connection) {1630 transportLogic.reconnect(connection, this.name);1631 },1632 lostConnection: function (connection) {1633 this.reconnect(connection);1634 },1635 send: function (connection, data) {1636 transportLogic.ajaxSend(connection, data);1637 },1638 stop: function (connection) {1639 // Don't trigger a reconnect after stopping1640 clearReconnectAttemptTimeout(connection);1641 transportLogic.clearReconnectTimeout(connection);1642 if (connection && connection.eventSource) {1643 connection.log("EventSource calling close().");1644 connection.eventSource.close();1645 connection.eventSource = null;1646 delete connection.eventSource;1647 }1648 },1649 abort: function (connection, async) {1650 transportLogic.ajaxAbort(connection, async);1651 }1652 };1653}(window.jQuery, window));1654/* jquery.signalR.transports.foreverFrame.js */1655// Copyright (c) .NET Foundation. All rights reserved.1656// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.1657/*global window:false */1658/// <reference path="jquery.signalR.transports.common.js" />1659(function ($, window, undefined) {1660 var signalR = $.signalR,1661 events = $.signalR.events,1662 changeState = $.signalR.changeState,1663 transportLogic = signalR.transports._logic,1664 createFrame = function () {1665 var frame = window.document.createElement("iframe");1666 frame.setAttribute("style", "position:absolute;top:0;left:0;width:0;height:0;visibility:hidden;");1667 return frame;1668 },1669 // Used to prevent infinite loading icon spins in older versions of ie1670 // We build this object inside a closure so we don't pollute the rest of1671 // the foreverFrame transport with unnecessary functions/utilities.1672 loadPreventer = (function () {1673 var loadingFixIntervalId = null,1674 loadingFixInterval = 1000,1675 attachedTo = 0;1676 return {1677 prevent: function () {1678 // Prevent additional iframe removal procedures from newer browsers1679 if (signalR._.ieVersion <= 8) {1680 // We only ever want to set the interval one time, so on the first attachedTo1681 if (attachedTo === 0) {1682 // Create and destroy iframe every 3 seconds to prevent loading icon, super hacky1683 loadingFixIntervalId = window.setInterval(function () {1684 var tempFrame = createFrame();1685 window.document.body.appendChild(tempFrame);1686 window.document.body.removeChild(tempFrame);1687 tempFrame = null;1688 }, loadingFixInterval);1689 }1690 attachedTo++;1691 }1692 },1693 cancel: function () {1694 // Only clear the interval if there's only one more object that the loadPreventer is attachedTo1695 if (attachedTo === 1) {1696 window.clearInterval(loadingFixIntervalId);1697 }1698 if (attachedTo > 0) {1699 attachedTo--;1700 }1701 }1702 };1703 })();1704 signalR.transports.foreverFrame = {1705 name: "foreverFrame",1706 supportsKeepAlive: function () {1707 return true;1708 },1709 // Added as a value here so we can create tests to verify functionality1710 iframeClearThreshold: 50,1711 start: function (connection, onSuccess, onFailed) {1712 var that = this,1713 frameId = (transportLogic.foreverFrame.count += 1),1714 url,1715 frame = createFrame(),1716 frameLoadHandler = function () {1717 connection.log("Forever frame iframe finished loading and is no longer receiving messages.");1718 if (!onFailed || !onFailed()) {1719 that.reconnect(connection);1720 }1721 };1722 if (window.EventSource) {1723 // If the browser supports SSE, don't use Forever Frame1724 if (onFailed) {1725 connection.log("Forever Frame is not supported by SignalR on browsers with SSE support.");1726 onFailed();1727 }1728 return;1729 }1730 frame.setAttribute("data-signalr-connection-id", connection.id);1731 // Start preventing loading icon1732 // This will only perform work if the loadPreventer is not attached to another connection.1733 loadPreventer.prevent();1734 // Build the url1735 url = transportLogic.getUrl(connection, this.name);1736 url += "&frameId=" + frameId;1737 // add frame to the document prior to setting URL to avoid caching issues.1738 window.document.documentElement.appendChild(frame);1739 connection.log("Binding to iframe's load event.");1740 if (frame.addEventListener) {1741 frame.addEventListener("load", frameLoadHandler, false);1742 } else if (frame.attachEvent) {1743 frame.attachEvent("onload", frameLoadHandler);1744 }1745 frame.src = url;1746 transportLogic.foreverFrame.connections[frameId] = connection;1747 connection.frame = frame;1748 connection.frameId = frameId;1749 if (onSuccess) {1750 connection.onSuccess = function () {1751 connection.log("Iframe transport started.");1752 onSuccess();1753 };1754 }1755 },1756 reconnect: function (connection) {1757 var that = this;1758 // Need to verify connection state and verify before the setTimeout occurs because an application sleep could occur during the setTimeout duration.1759 if (transportLogic.isConnectedOrReconnecting(connection) && transportLogic.verifyLastActive(connection)) {1760 window.setTimeout(function () {1761 // Verify that we're ok to reconnect.1762 if (!transportLogic.verifyLastActive(connection)) {1763 return;1764 }1765 if (connection.frame && transportLogic.ensureReconnectingState(connection)) {1766 var frame = connection.frame,1767 src = transportLogic.getUrl(connection, that.name, true) + "&frameId=" + connection.frameId;1768 connection.log("Updating iframe src to '" + src + "'.");1769 frame.src = src;1770 }1771 }, connection.reconnectDelay);1772 }1773 },1774 lostConnection: function (connection) {1775 this.reconnect(connection);1776 },1777 send: function (connection, data) {1778 transportLogic.ajaxSend(connection, data);1779 },1780 receive: function (connection, data) {1781 var cw,1782 body,1783 response;1784 if (connection.json !== connection._originalJson) {1785 // If there's a custom JSON parser configured then serialize the object1786 // using the original (browser) JSON parser and then deserialize it using1787 // the custom parser (connection._parseResponse does that). This is so we1788 // can easily send the response from the server as "raw" JSON but still1789 // support custom JSON deserialization in the browser.1790 data = connection._originalJson.stringify(data);1791 }1792 response = connection._parseResponse(data);1793 transportLogic.processMessages(connection, response, connection.onSuccess);1794 // Protect against connection stopping from a callback trigger within the processMessages above.1795 if (connection.state === $.signalR.connectionState.connected) {1796 // Delete the script & div elements1797 connection.frameMessageCount = (connection.frameMessageCount || 0) + 1;1798 if (connection.frameMessageCount > signalR.transports.foreverFrame.iframeClearThreshold) {1799 connection.frameMessageCount = 0;1800 cw = connection.frame.contentWindow || connection.frame.contentDocument;1801 if (cw && cw.document && cw.document.body) {1802 body = cw.document.body;1803 // Remove all the child elements from the iframe's body to conserver memory1804 while (body.firstChild) {1805 body.removeChild(body.firstChild);1806 }1807 }1808 }1809 }1810 },1811 stop: function (connection) {1812 var cw = null;1813 // Stop attempting to prevent loading icon1814 loadPreventer.cancel();1815 if (connection.frame) {1816 if (connection.frame.stop) {1817 connection.frame.stop();1818 } else {1819 try {1820 cw = connection.frame.contentWindow || connection.frame.contentDocument;1821 if (cw.document && cw.document.execCommand) {1822 cw.document.execCommand("Stop");1823 }1824 }1825 catch (e) {1826 connection.log("Error occurred when stopping foreverFrame transport. Message = " + e.message + ".");1827 }1828 }1829 // Ensure the iframe is where we left it1830 if (connection.frame.parentNode === window.document.body) {1831 window.document.body.removeChild(connection.frame);1832 }1833 delete transportLogic.foreverFrame.connections[connection.frameId];1834 connection.frame = null;1835 connection.frameId = null;1836 delete connection.frame;1837 delete connection.frameId;1838 delete connection.onSuccess;1839 delete connection.frameMessageCount;1840 connection.log("Stopping forever frame.");1841 }1842 },1843 abort: function (connection, async) {1844 transportLogic.ajaxAbort(connection, async);1845 },1846 getConnection: function (id) {1847 return transportLogic.foreverFrame.connections[id];1848 },1849 started: function (connection) {1850 if (changeState(connection,1851 signalR.connectionState.reconnecting,1852 signalR.connectionState.connected) === true) {1853 $(connection).triggerHandler(events.onReconnect);1854 }1855 }1856 };1857}(window.jQuery, window));1858/* jquery.signalR.transports.longPolling.js */1859// Copyright (c) .NET Foundation. All rights reserved.1860// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.1861/*global window:false */1862/// <reference path="jquery.signalR.transports.common.js" />1863(function ($, window, undefined) {1864 var signalR = $.signalR,1865 events = $.signalR.events,1866 changeState = $.signalR.changeState,1867 isDisconnecting = $.signalR.isDisconnecting,1868 transportLogic = signalR.transports._logic;1869 signalR.transports.longPolling = {1870 name: "longPolling",1871 supportsKeepAlive: function () {1872 return false;1873 },1874 reconnectDelay: 3000,1875 start: function (connection, onSuccess, onFailed) {1876 /// <summary>Starts the long polling connection</summary>1877 /// <param name="connection" type="signalR">The SignalR connection to start</param>1878 var that = this,1879 fireConnect = function () {1880 fireConnect = $.noop;1881 connection.log("LongPolling connected.");1882 if (onSuccess) {1883 onSuccess();1884 } else {1885 connection.log("WARNING! The client received an init message after reconnecting.");1886 }1887 },1888 tryFailConnect = function (error) {1889 if (onFailed(error)) {1890 connection.log("LongPolling failed to connect.");1891 return true;1892 }1893 return false;1894 },1895 privateData = connection._,1896 reconnectErrors = 0,1897 fireReconnected = function (instance) {1898 window.clearTimeout(privateData.reconnectTimeoutId);1899 privateData.reconnectTimeoutId = null;1900 if (changeState(instance,1901 signalR.connectionState.reconnecting,1902 signalR.connectionState.connected) === true) {1903 // Successfully reconnected!1904 instance.log("Raising the reconnect event");1905 $(instance).triggerHandler(events.onReconnect);1906 }1907 },1908 // 1 hour1909 maxFireReconnectedTimeout = 3600000;1910 if (connection.pollXhr) {1911 connection.log("Polling xhr requests already exists, aborting.");1912 connection.stop();1913 }1914 connection.messageId = null;1915 privateData.reconnectTimeoutId = null;1916 privateData.pollTimeoutId = window.setTimeout(function () {1917 (function poll(instance, raiseReconnect) {1918 var messageId = instance.messageId,1919 connect = (messageId === null),1920 reconnecting = !connect,1921 polling = !raiseReconnect,1922 url = transportLogic.getUrl(instance, that.name, reconnecting, polling, true /* use Post for longPolling */),1923 postData = {};1924 if (instance.messageId) {1925 postData.messageId = instance.messageId;1926 }1927 if (instance.groupsToken) {1928 postData.groupsToken = instance.groupsToken;1929 }1930 // If we've disconnected during the time we've tried to re-instantiate the poll then stop.1931 if (isDisconnecting(instance) === true) {1932 return;1933 }1934 connection.log("Opening long polling request to '" + url + "'.");1935 instance.pollXhr = transportLogic.ajax(connection, {1936 xhrFields: {1937 onprogress: function () {1938 transportLogic.markLastMessage(connection);1939 }1940 },1941 url: url,1942 type: "POST",1943 contentType: signalR._.defaultContentType,1944 data: postData,1945 timeout: connection._.pollTimeout,1946 success: function (result) {1947 var minData,1948 delay = 0,1949 data,1950 shouldReconnect;1951 connection.log("Long poll complete.");1952 // Reset our reconnect errors so if we transition into a reconnecting state again we trigger1953 // reconnected quickly1954 reconnectErrors = 0;1955 try {1956 // Remove any keep-alives from the beginning of the result1957 minData = connection._parseResponse(result);1958 }1959 catch (error) {1960 transportLogic.handleParseFailure(instance, result, error, tryFailConnect, instance.pollXhr);1961 return;1962 }1963 // If there's currently a timeout to trigger reconnect, fire it now before processing messages1964 if (privateData.reconnectTimeoutId !== null) {1965 fireReconnected(instance);1966 }1967 if (minData) {1968 data = transportLogic.maximizePersistentResponse(minData);1969 }1970 transportLogic.processMessages(instance, minData, fireConnect);1971 if (data &&1972 $.type(data.LongPollDelay) === "number") {1973 delay = data.LongPollDelay;1974 }1975 if (isDisconnecting(instance) === true) {1976 return;1977 }1978 shouldReconnect = data && data.ShouldReconnect;1979 if (shouldReconnect) {1980 // Transition into the reconnecting state1981 // If this fails then that means that the user transitioned the connection into a invalid state in processMessages.1982 if (!transportLogic.ensureReconnectingState(instance)) {1983 return;1984 }1985 }1986 // We never want to pass a raiseReconnect flag after a successful poll. This is handled via the error function1987 if (delay > 0) {1988 privateData.pollTimeoutId = window.setTimeout(function () {1989 poll(instance, shouldReconnect);1990 }, delay);1991 } else {1992 poll(instance, shouldReconnect);1993 }1994 },1995 error: function (data, textStatus) {1996 var error = signalR._.transportError(signalR.resources.longPollFailed, connection.transport, data, instance.pollXhr);1997 // Stop trying to trigger reconnect, connection is in an error state1998 // If we're not in the reconnect state this will noop1999 window.clearTimeout(privateData.reconnectTimeoutId);2000 privateData.reconnectTimeoutId = null;2001 if (textStatus === "abort") {2002 connection.log("Aborted xhr request.");2003 return;2004 }2005 if (!tryFailConnect(error)) {2006 // Increment our reconnect errors, we assume all errors to be reconnect errors2007 // In the case that it's our first error this will cause Reconnect to be fired2008 // after 1 second due to reconnectErrors being = 1.2009 reconnectErrors++;2010 if (connection.state !== signalR.connectionState.reconnecting) {2011 connection.log("An error occurred using longPolling. Status = " + textStatus + ". Response = " + data.responseText + ".");2012 $(instance).triggerHandler(events.onError, [error]);2013 }2014 // We check the state here to verify that we're not in an invalid state prior to verifying Reconnect.2015 // If we're not in connected or reconnecting then the next ensureReconnectingState check will fail and will return.2016 // Therefore we don't want to change that failure code path.2017 if ((connection.state === signalR.connectionState.connected ||2018 connection.state === signalR.connectionState.reconnecting) &&2019 !transportLogic.verifyLastActive(connection)) {2020 return;2021 }2022 // Transition into the reconnecting state2023 // If this fails then that means that the user transitioned the connection into the disconnected or connecting state within the above error handler trigger.2024 if (!transportLogic.ensureReconnectingState(instance)) {2025 return;2026 }2027 // Call poll with the raiseReconnect flag as true after the reconnect delay2028 privateData.pollTimeoutId = window.setTimeout(function () {2029 poll(instance, true);2030 }, that.reconnectDelay);2031 }2032 }2033 });2034 // This will only ever pass after an error has occurred via the poll ajax procedure.2035 if (reconnecting && raiseReconnect === true) {2036 // We wait to reconnect depending on how many times we've failed to reconnect.2037 // This is essentially a heuristic that will exponentially increase in wait time before2038 // triggering reconnected. This depends on the "error" handler of Poll to cancel this2039 // timeout if it triggers before the Reconnected event fires.2040 // The Math.min at the end is to ensure that the reconnect timeout does not overflow.2041 privateData.reconnectTimeoutId = window.setTimeout(function () { fireReconnected(instance); }, Math.min(1000 * (Math.pow(2, reconnectErrors) - 1), maxFireReconnectedTimeout));2042 }2043 }(connection));2044 }, 250); // Have to delay initial poll so Chrome doesn't show loader spinner in tab2045 },2046 lostConnection: function (connection) {2047 if (connection.pollXhr) {2048 connection.pollXhr.abort("lostConnection");2049 }2050 },2051 send: function (connection, data) {2052 transportLogic.ajaxSend(connection, data);2053 },2054 stop: function (connection) {2055 /// <summary>Stops the long polling connection</summary>2056 /// <param name="connection" type="signalR">The SignalR connection to stop</param>2057 window.clearTimeout(connection._.pollTimeoutId);2058 window.clearTimeout(connection._.reconnectTimeoutId);2059 delete connection._.pollTimeoutId;2060 delete connection._.reconnectTimeoutId;2061 if (connection.pollXhr) {2062 connection.pollXhr.abort();2063 connection.pollXhr = null;2064 delete connection.pollXhr;2065 }2066 },2067 abort: function (connection, async) {2068 transportLogic.ajaxAbort(connection, async);2069 }2070 };2071}(window.jQuery, window));2072/* jquery.signalR.hubs.js */2073// Copyright (c) .NET Foundation. All rights reserved.2074// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.2075/*global window:false */2076/// <reference path="jquery.signalR.core.js" />2077(function ($, window, undefined) {2078 var eventNamespace = ".hubProxy",2079 signalR = $.signalR;2080 function makeEventName(event) {2081 return event + eventNamespace;2082 }2083 // Equivalent to Array.prototype.map2084 function map(arr, fun, thisp) {2085 var i,2086 length = arr.length,2087 result = [];2088 for (i = 0; i < length; i += 1) {2089 if (arr.hasOwnProperty(i)) {2090 result[i] = fun.call(thisp, arr[i], i, arr);2091 }2092 }2093 return result;2094 }2095 function getArgValue(a) {2096 return $.isFunction(a) ? null : ($.type(a) === "undefined" ? null : a);2097 }2098 function hasMembers(obj) {2099 for (var key in obj) {2100 // If we have any properties in our callback map then we have callbacks and can exit the loop via return2101 if (obj.hasOwnProperty(key)) {2102 return true;2103 }2104 }2105 return false;2106 }2107 function clearInvocationCallbacks(connection, error) {2108 /// <param name="connection" type="hubConnection" />2109 var callbacks = connection._.invocationCallbacks,2110 callback;2111 if (hasMembers(callbacks)) {2112 connection.log("Clearing hub invocation callbacks with error: " + error + ".");2113 }2114 // Reset the callback cache now as we have a local var referencing it2115 connection._.invocationCallbackId = 0;2116 delete connection._.invocationCallbacks;2117 connection._.invocationCallbacks = {};2118 // Loop over the callbacks and invoke them.2119 // We do this using a local var reference and *after* we've cleared the cache2120 // so that if a fail callback itself tries to invoke another method we don't2121 // end up with its callback in the list we're looping over.2122 for (var callbackId in callbacks) {2123 callback = callbacks[callbackId];2124 callback.method.call(callback.scope, { E: error });2125 }2126 }2127 // hubProxy2128 function hubProxy(hubConnection, hubName) {2129 /// <summary>2130 /// Creates a new proxy object for the given hub connection that can be used to invoke2131 /// methods on server hubs and handle client method invocation requests from the server.2132 /// </summary>2133 return new hubProxy.fn.init(hubConnection, hubName);2134 }2135 hubProxy.fn = hubProxy.prototype = {2136 init: function (connection, hubName) {2137 this.state = {};2138 this.connection = connection;2139 this.hubName = hubName;2140 this._ = {2141 callbackMap: {}2142 };2143 },2144 constructor: hubProxy,2145 hasSubscriptions: function () {2146 return hasMembers(this._.callbackMap);2147 },2148 on: function (eventName, callback) {2149 /// <summary>Wires up a callback to be invoked when a invocation request is received from the server hub.</summary>2150 /// <param name="eventName" type="String">The name of the hub event to register the callback for.</param>2151 /// <param name="callback" type="Function">The callback to be invoked.</param>2152 var that = this,2153 callbackMap = that._.callbackMap;2154 // Normalize the event name to lowercase2155 eventName = eventName.toLowerCase();2156 // If there is not an event registered for this callback yet we want to create its event space in the callback map.2157 if (!callbackMap[eventName]) {2158 callbackMap[eventName] = {};2159 }2160 // Map the callback to our encompassed function2161 callbackMap[eventName][callback] = function (e, data) {2162 callback.apply(that, data);2163 };2164 $(that).bind(makeEventName(eventName), callbackMap[eventName][callback]);2165 return that;2166 },2167 off: function (eventName, callback) {2168 /// <summary>Removes the callback invocation request from the server hub for the given event name.</summary>2169 /// <param name="eventName" type="String">The name of the hub event to unregister the callback for.</param>2170 /// <param name="callback" type="Function">The callback to be invoked.</param>2171 var that = this,2172 callbackMap = that._.callbackMap,2173 callbackSpace;2174 // Normalize the event name to lowercase2175 eventName = eventName.toLowerCase();2176 callbackSpace = callbackMap[eventName];2177 // Verify that there is an event space to unbind2178 if (callbackSpace) {2179 // Only unbind if there's an event bound with eventName and a callback with the specified callback2180 if (callbackSpace[callback]) {2181 $(that).unbind(makeEventName(eventName), callbackSpace[callback]);2182 // Remove the callback from the callback map2183 delete callbackSpace[callback];2184 // Check if there are any members left on the event, if not we need to destroy it.2185 if (!hasMembers(callbackSpace)) {2186 delete callbackMap[eventName];2187 }2188 } else if (!callback) { // Check if we're removing the whole event and we didn't error because of an invalid callback2189 $(that).unbind(makeEventName(eventName));2190 delete callbackMap[eventName];2191 }2192 }2193 return that;2194 },2195 invoke: function (methodName) {2196 /// <summary>Invokes a server hub method with the given arguments.</summary>2197 /// <param name="methodName" type="String">The name of the server hub method.</param>2198 var that = this,2199 connection = that.connection,2200 args = $.makeArray(arguments).slice(1),2201 argValues = map(args, getArgValue),2202 data = { H: that.hubName, M: methodName, A: argValues, I: connection._.invocationCallbackId },2203 d = $.Deferred(),2204 callback = function (minResult) {2205 var result = that._maximizeHubResponse(minResult),2206 source,2207 error;2208 // Update the hub state2209 $.extend(that.state, result.State);2210 if (result.Progress) {2211 if (d.notifyWith) {2212 // Progress is only supported in jQuery 1.7+2213 d.notifyWith(that, [result.Progress.Data]);2214 } else if(!connection._.progressjQueryVersionLogged) {2215 connection.log("A hub method invocation progress update was received but the version of jQuery in use (" + $.prototype.jquery + ") does not support progress updates. Upgrade to jQuery 1.7+ to receive progress notifications.");2216 connection._.progressjQueryVersionLogged = true;2217 }2218 } else if (result.Error) {2219 // Server hub method threw an exception, log it & reject the deferred2220 if (result.StackTrace) {2221 connection.log(result.Error + "\n" + result.StackTrace + ".");2222 }2223 // result.ErrorData is only set if a HubException was thrown2224 source = result.IsHubException ? "HubException" : "Exception";2225 error = signalR._.error(result.Error, source);2226 error.data = result.ErrorData;2227 connection.log(that.hubName + "." + methodName + " failed to execute. Error: " + error.message);2228 d.rejectWith(that, [error]);2229 } else {2230 // Server invocation succeeded, resolve the deferred2231 connection.log("Invoked " + that.hubName + "." + methodName);2232 d.resolveWith(that, [result.Result]);2233 }2234 };2235 connection._.invocationCallbacks[connection._.invocationCallbackId.toString()] = { scope: that, method: callback };2236 connection._.invocationCallbackId += 1;2237 if (!$.isEmptyObject(that.state)) {2238 data.S = that.state;2239 }2240 connection.log("Invoking " + that.hubName + "." + methodName);2241 connection.send(data);2242 return d.promise();2243 },2244 _maximizeHubResponse: function (minHubResponse) {2245 return {2246 State: minHubResponse.S,2247 Result: minHubResponse.R,2248 Progress: minHubResponse.P ? {2249 Id: minHubResponse.P.I,2250 Data: minHubResponse.P.D2251 } : null,2252 Id: minHubResponse.I,2253 IsHubException: minHubResponse.H,2254 Error: minHubResponse.E,2255 StackTrace: minHubResponse.T,2256 ErrorData: minHubResponse.D2257 };2258 }2259 };2260 hubProxy.fn.init.prototype = hubProxy.fn;2261 // hubConnection2262 function hubConnection(url, options) {2263 /// <summary>Creates a new hub connection.</summary>2264 /// <param name="url" type="String">[Optional] The hub route url, defaults to "/signalr".</param>2265 /// <param name="options" type="Object">[Optional] Settings to use when creating the hubConnection.</param>2266 var settings = {2267 qs: null,2268 logging: false,2269 useDefaultPath: true2270 };2271 $.extend(settings, options);2272 if (!url || settings.useDefaultPath) {2273 url = (url || "") + "/signalr";2274 }2275 return new hubConnection.fn.init(url, settings);2276 }...

Full Screen

Full Screen

jquery.signalR-2.2.0.js

Source:jquery.signalR-2.2.0.js Github

copy

Full Screen

...826 // Check if the keep alive has completely timed out827 if (timeElapsed >= keepAliveData.timeout) {828 connection.log("Keep alive timed out. Notifying transport that connection has been lost.");829 // Notify transport that the connection has been lost830 connection.transport.lostConnection(connection);831 } else if (timeElapsed >= keepAliveData.timeoutWarning) {832 // This is to assure that the user only gets a single warning833 if (!keepAliveData.userNotified) {834 connection.log("Keep alive has been missed, connection may be dead/slow.");835 $(connection).triggerHandler(events.onConnectionSlow);836 keepAliveData.userNotified = true;837 }838 } else {839 keepAliveData.userNotified = false;840 }841 }842 }843 function getAjaxUrl(connection, path) {844 var url = connection.url + path;845 if (connection.transport) {846 url += "?transport=" + connection.transport.name;847 }848 return transportLogic.prepareQueryString(connection, url);849 }850 function InitHandler(connection) {851 this.connection = connection;852 this.startRequested = false;853 this.startCompleted = false;854 this.connectionStopped = false;855 }856 InitHandler.prototype = {857 start: function (transport, onSuccess, onFallback) {858 var that = this,859 connection = that.connection,860 failCalled = false;861 if (that.startRequested || that.connectionStopped) {862 connection.log("WARNING! " + transport.name + " transport cannot be started. Initialization ongoing or completed.");863 return;864 }865 connection.log(transport.name + " transport starting.");866 that.transportTimeoutHandle = window.setTimeout(function () {867 if (!failCalled) {868 failCalled = true;869 connection.log(transport.name + " transport timed out when trying to connect.");870 that.transportFailed(transport, undefined, onFallback);871 }872 }, connection._.totalTransportConnectTimeout);873 transport.start(connection, function () {874 if (!failCalled) {875 that.initReceived(transport, onSuccess);876 }877 }, function (error) {878 // Don't allow the same transport to cause onFallback to be called twice879 if (!failCalled) {880 failCalled = true;881 that.transportFailed(transport, error, onFallback);882 }883 // Returns true if the transport should stop;884 // false if it should attempt to reconnect885 return !that.startCompleted || that.connectionStopped;886 });887 },888 stop: function () {889 this.connectionStopped = true;890 window.clearTimeout(this.transportTimeoutHandle);891 signalR.transports._logic.tryAbortStartRequest(this.connection);892 },893 initReceived: function (transport, onSuccess) {894 var that = this,895 connection = that.connection;896 if (that.startRequested) {897 connection.log("WARNING! The client received multiple init messages.");898 return;899 }900 if (that.connectionStopped) {901 return;902 }903 that.startRequested = true;904 window.clearTimeout(that.transportTimeoutHandle);905 connection.log(transport.name + " transport connected. Initiating start request.");906 signalR.transports._logic.ajaxStart(connection, function () {907 that.startCompleted = true;908 onSuccess();909 });910 },911 transportFailed: function (transport, error, onFallback) {912 var connection = this.connection,913 deferred = connection._deferral,914 wrappedError;915 if (this.connectionStopped) {916 return;917 }918 window.clearTimeout(this.transportTimeoutHandle);919 if (!this.startRequested) {920 transport.stop(connection);921 connection.log(transport.name + " transport failed to connect. Attempting to fall back.");922 onFallback();923 } else if (!this.startCompleted) {924 // Do not attempt to fall back if a start request is ongoing during a transport failure.925 // Instead, trigger an error and stop the connection.926 wrappedError = signalR._.error(signalR.resources.errorDuringStartRequest, error);927 connection.log(transport.name + " transport failed during the start request. Stopping the connection.");928 $(connection).triggerHandler(events.onError, [wrappedError]);929 if (deferred) {930 deferred.reject(wrappedError);931 }932 connection.stop();933 } else {934 // The start request has completed, but the connection has not stopped.935 // No need to do anything here. The transport should attempt its normal reconnect logic.936 }937 }938 };939 transportLogic = signalR.transports._logic = {940 ajax: function (connection, options) {941 return $.ajax(942 $.extend(/*deep copy*/ true, {}, $.signalR.ajaxDefaults, {943 type: "GET",944 data: {},945 xhrFields: { withCredentials: connection.withCredentials },946 contentType: connection.contentType,947 dataType: connection.ajaxDataType948 }, options));949 },950 pingServer: function (connection) {951 /// <summary>Pings the server</summary>952 /// <param name="connection" type="signalr">Connection associated with the server ping</param>953 /// <returns type="signalR" />954 var url,955 xhr,956 deferral = $.Deferred();957 if (connection.transport) {958 url = connection.url + "/ping";959 url = transportLogic.addQs(url, connection.qs);960 xhr = transportLogic.ajax(connection, {961 url: url,962 success: function (result) {963 var data;964 try {965 data = connection._parseResponse(result);966 }967 catch (error) {968 deferral.reject(969 signalR._.transportError(970 signalR.resources.pingServerFailedParse,971 connection.transport,972 error,973 xhr974 )975 );976 connection.stop();977 return;978 }979 if (data.Response === "pong") {980 deferral.resolve();981 }982 else {983 deferral.reject(984 signalR._.transportError(985 signalR._.format(signalR.resources.pingServerFailedInvalidResponse, result),986 connection.transport,987 null /* error */,988 xhr989 )990 );991 }992 },993 error: function (error) {994 if (error.status === 401 || error.status === 403) {995 deferral.reject(996 signalR._.transportError(997 signalR._.format(signalR.resources.pingServerFailedStatusCode, error.status),998 connection.transport,999 error,1000 xhr1001 )1002 );1003 connection.stop();1004 }1005 else {1006 deferral.reject(1007 signalR._.transportError(1008 signalR.resources.pingServerFailed,1009 connection.transport,1010 error,1011 xhr1012 )1013 );1014 }1015 }1016 });1017 }1018 else {1019 deferral.reject(1020 signalR._.transportError(1021 signalR.resources.noConnectionTransport,1022 connection.transport1023 )1024 );1025 }1026 return deferral.promise();1027 },1028 prepareQueryString: function (connection, url) {1029 var preparedUrl;1030 // Use addQs to start since it handles the ?/& prefix for us1031 preparedUrl = transportLogic.addQs(url, "clientProtocol=" + connection.clientProtocol);1032 // Add the user-specified query string params if any1033 preparedUrl = transportLogic.addQs(preparedUrl, connection.qs);1034 if (connection.token) {1035 preparedUrl += "&connectionToken=" + window.encodeURIComponent(connection.token);1036 }1037 if (connection.data) {1038 preparedUrl += "&connectionData=" + window.encodeURIComponent(connection.data);1039 }1040 return preparedUrl;1041 },1042 addQs: function (url, qs) {1043 var appender = url.indexOf("?") !== -1 ? "&" : "?",1044 firstChar;1045 if (!qs) {1046 return url;1047 }1048 if (typeof (qs) === "object") {1049 return url + appender + $.param(qs);1050 }1051 if (typeof (qs) === "string") {1052 firstChar = qs.charAt(0);1053 if (firstChar === "?" || firstChar === "&") {1054 appender = "";1055 }1056 return url + appender + qs;1057 }1058 throw new Error("Query string property must be either a string or object.");1059 },1060 // BUG #2953: The url needs to be same otherwise it will cause a memory leak1061 getUrl: function (connection, transport, reconnecting, poll, ajaxPost) {1062 /// <summary>Gets the url for making a GET based connect request</summary>1063 var baseUrl = transport === "webSockets" ? "" : connection.baseUrl,1064 url = baseUrl + connection.appRelativeUrl,1065 qs = "transport=" + transport;1066 if (!ajaxPost && connection.groupsToken) {1067 qs += "&groupsToken=" + window.encodeURIComponent(connection.groupsToken);1068 }1069 if (!reconnecting) {1070 url += "/connect";1071 } else {1072 if (poll) {1073 // longPolling transport specific1074 url += "/poll";1075 } else {1076 url += "/reconnect";1077 }1078 if (!ajaxPost && connection.messageId) {1079 qs += "&messageId=" + window.encodeURIComponent(connection.messageId);1080 }1081 }1082 url += "?" + qs;1083 url = transportLogic.prepareQueryString(connection, url);1084 if (!ajaxPost) {1085 url += "&tid=" + Math.floor(Math.random() * 11);1086 }1087 return url;1088 },1089 maximizePersistentResponse: function (minPersistentResponse) {1090 return {1091 MessageId: minPersistentResponse.C,1092 Messages: minPersistentResponse.M,1093 Initialized: typeof (minPersistentResponse.S) !== "undefined" ? true : false,1094 ShouldReconnect: typeof (minPersistentResponse.T) !== "undefined" ? true : false,1095 LongPollDelay: minPersistentResponse.L,1096 GroupsToken: minPersistentResponse.G1097 };1098 },1099 updateGroups: function (connection, groupsToken) {1100 if (groupsToken) {1101 connection.groupsToken = groupsToken;1102 }1103 },1104 stringifySend: function (connection, message) {1105 if (typeof (message) === "string" || typeof (message) === "undefined" || message === null) {1106 return message;1107 }1108 return connection.json.stringify(message);1109 },1110 ajaxSend: function (connection, data) {1111 var payload = transportLogic.stringifySend(connection, data),1112 url = getAjaxUrl(connection, "/send"),1113 xhr,1114 onFail = function (error, connection) {1115 $(connection).triggerHandler(events.onError, [signalR._.transportError(signalR.resources.sendFailed, connection.transport, error, xhr), data]);1116 };1117 xhr = transportLogic.ajax(connection, {1118 url: url,1119 type: connection.ajaxDataType === "jsonp" ? "GET" : "POST",1120 contentType: signalR._.defaultContentType,1121 data: {1122 data: payload1123 },1124 success: function (result) {1125 var res;1126 if (result) {1127 try {1128 res = connection._parseResponse(result);1129 }1130 catch (error) {1131 onFail(error, connection);1132 connection.stop();1133 return;1134 }1135 transportLogic.triggerReceived(connection, res);1136 }1137 },1138 error: function (error, textStatus) {1139 if (textStatus === "abort" || textStatus === "parsererror") {1140 // The parsererror happens for sends that don't return any data, and hence1141 // don't write the jsonp callback to the response. This is harder to fix on the server1142 // so just hack around it on the client for now.1143 return;1144 }1145 onFail(error, connection);1146 }1147 });1148 return xhr;1149 },1150 ajaxAbort: function (connection, async) {1151 if (typeof (connection.transport) === "undefined") {1152 return;1153 }1154 // Async by default unless explicitly overidden1155 async = typeof async === "undefined" ? true : async;1156 var url = getAjaxUrl(connection, "/abort");1157 transportLogic.ajax(connection, {1158 url: url,1159 async: async,1160 timeout: 1000,1161 type: "POST"1162 });1163 connection.log("Fired ajax abort async = " + async + ".");1164 },1165 ajaxStart: function (connection, onSuccess) {1166 var rejectDeferred = function (error) {1167 var deferred = connection._deferral;1168 if (deferred) {1169 deferred.reject(error);1170 }1171 },1172 triggerStartError = function (error) {1173 connection.log("The start request failed. Stopping the connection.");1174 $(connection).triggerHandler(events.onError, [error]);1175 rejectDeferred(error);1176 connection.stop();1177 };1178 connection._.startRequest = transportLogic.ajax(connection, {1179 url: getAjaxUrl(connection, "/start"),1180 success: function (result, statusText, xhr) {1181 var data;1182 try {1183 data = connection._parseResponse(result);1184 } catch (error) {1185 triggerStartError(signalR._.error(1186 signalR._.format(signalR.resources.errorParsingStartResponse, result),1187 error, xhr));1188 return;1189 }1190 if (data.Response === "started") {1191 onSuccess();1192 } else {1193 triggerStartError(signalR._.error(1194 signalR._.format(signalR.resources.invalidStartResponse, result),1195 null /* error */, xhr));1196 }1197 },1198 error: function (xhr, statusText, error) {1199 if (statusText !== startAbortText) {1200 triggerStartError(signalR._.error(1201 signalR.resources.errorDuringStartRequest,1202 error, xhr));1203 } else {1204 // Stop has been called, no need to trigger the error handler1205 // or stop the connection again with onStartError1206 connection.log("The start request aborted because connection.stop() was called.");1207 rejectDeferred(signalR._.error(1208 signalR.resources.stoppedDuringStartRequest,1209 null /* error */, xhr));1210 }1211 }1212 });1213 },1214 tryAbortStartRequest: function (connection) {1215 if (connection._.startRequest) {1216 // If the start request has already completed this will noop.1217 connection._.startRequest.abort(startAbortText);1218 delete connection._.startRequest;1219 }1220 },1221 tryInitialize: function (persistentResponse, onInitialized) {1222 if (persistentResponse.Initialized) {1223 onInitialized();1224 }1225 },1226 triggerReceived: function (connection, data) {1227 if (!connection._.connectingMessageBuffer.tryBuffer(data)) {1228 $(connection).triggerHandler(events.onReceived, [data]);1229 }1230 },1231 processMessages: function (connection, minData, onInitialized) {1232 var data;1233 // Update the last message time stamp1234 transportLogic.markLastMessage(connection);1235 if (minData) {1236 data = transportLogic.maximizePersistentResponse(minData);1237 transportLogic.updateGroups(connection, data.GroupsToken);1238 if (data.MessageId) {1239 connection.messageId = data.MessageId;1240 }1241 if (data.Messages) {1242 $.each(data.Messages, function (index, message) {1243 transportLogic.triggerReceived(connection, message);1244 });1245 transportLogic.tryInitialize(data, onInitialized);1246 }1247 }1248 },1249 monitorKeepAlive: function (connection) {1250 var keepAliveData = connection._.keepAliveData;1251 // If we haven't initiated the keep alive timeouts then we need to1252 if (!keepAliveData.monitoring) {1253 keepAliveData.monitoring = true;1254 transportLogic.markLastMessage(connection);1255 // Save the function so we can unbind it on stop1256 connection._.keepAliveData.reconnectKeepAliveUpdate = function () {1257 // Mark a new message so that keep alive doesn't time out connections1258 transportLogic.markLastMessage(connection);1259 };1260 // Update Keep alive on reconnect1261 $(connection).bind(events.onReconnect, connection._.keepAliveData.reconnectKeepAliveUpdate);1262 connection.log("Now monitoring keep alive with a warning timeout of " + keepAliveData.timeoutWarning + ", keep alive timeout of " + keepAliveData.timeout + " and disconnecting timeout of " + connection.disconnectTimeout);1263 } else {1264 connection.log("Tried to monitor keep alive but it's already being monitored.");1265 }1266 },1267 stopMonitoringKeepAlive: function (connection) {1268 var keepAliveData = connection._.keepAliveData;1269 // Only attempt to stop the keep alive monitoring if its being monitored1270 if (keepAliveData.monitoring) {1271 // Stop monitoring1272 keepAliveData.monitoring = false;1273 // Remove the updateKeepAlive function from the reconnect event1274 $(connection).unbind(events.onReconnect, connection._.keepAliveData.reconnectKeepAliveUpdate);1275 // Clear all the keep alive data1276 connection._.keepAliveData = {};1277 connection.log("Stopping the monitoring of the keep alive.");1278 }1279 },1280 startHeartbeat: function (connection) {1281 connection._.lastActiveAt = new Date().getTime();1282 beat(connection);1283 },1284 markLastMessage: function (connection) {1285 connection._.lastMessageAt = new Date().getTime();1286 },1287 markActive: function (connection) {1288 if (transportLogic.verifyLastActive(connection)) {1289 connection._.lastActiveAt = new Date().getTime();1290 return true;1291 }1292 return false;1293 },1294 isConnectedOrReconnecting: function (connection) {1295 return connection.state === signalR.connectionState.connected ||1296 connection.state === signalR.connectionState.reconnecting;1297 },1298 ensureReconnectingState: function (connection) {1299 if (changeState(connection,1300 signalR.connectionState.connected,1301 signalR.connectionState.reconnecting) === true) {1302 $(connection).triggerHandler(events.onReconnecting);1303 }1304 return connection.state === signalR.connectionState.reconnecting;1305 },1306 clearReconnectTimeout: function (connection) {1307 if (connection && connection._.reconnectTimeout) {1308 window.clearTimeout(connection._.reconnectTimeout);1309 delete connection._.reconnectTimeout;1310 }1311 },1312 verifyLastActive: function (connection) {1313 if (new Date().getTime() - connection._.lastActiveAt >= connection.reconnectWindow) {1314 var message = signalR._.format(signalR.resources.reconnectWindowTimeout, new Date(connection._.lastActiveAt), connection.reconnectWindow);1315 connection.log(message);1316 $(connection).triggerHandler(events.onError, [signalR._.error(message, /* source */ "TimeoutException")]);1317 connection.stop(/* async */ false, /* notifyServer */ false);1318 return false;1319 }1320 return true;1321 },1322 reconnect: function (connection, transportName) {1323 var transport = signalR.transports[transportName];1324 // We should only set a reconnectTimeout if we are currently connected1325 // and a reconnectTimeout isn't already set.1326 if (transportLogic.isConnectedOrReconnecting(connection) && !connection._.reconnectTimeout) {1327 // Need to verify before the setTimeout occurs because an application sleep could occur during the setTimeout duration.1328 if (!transportLogic.verifyLastActive(connection)) {1329 return;1330 }1331 connection._.reconnectTimeout = window.setTimeout(function () {1332 if (!transportLogic.verifyLastActive(connection)) {1333 return;1334 }1335 transport.stop(connection);1336 if (transportLogic.ensureReconnectingState(connection)) {1337 connection.log(transportName + " reconnecting.");1338 transport.start(connection);1339 }1340 }, connection.reconnectDelay);1341 }1342 },1343 handleParseFailure: function (connection, result, error, onFailed, context) {1344 var wrappedError = signalR._.transportError(1345 signalR._.format(signalR.resources.parseFailed, result),1346 connection.transport,1347 error,1348 context);1349 // If we're in the initialization phase trigger onFailed, otherwise stop the connection.1350 if (onFailed && onFailed(wrappedError)) {1351 connection.log("Failed to parse server response while attempting to connect.");1352 } else {1353 $(connection).triggerHandler(events.onError, [wrappedError]);1354 connection.stop();1355 }1356 },1357 initHandler: function (connection) {1358 return new InitHandler(connection);1359 },1360 foreverFrame: {1361 count: 0,1362 connections: {}1363 }1364 };1365}(window.jQuery, window));1366/* jquery.signalR.transports.webSockets.js */1367// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.md in the project root for license information.1368/*global window:false */1369/// <reference path="jquery.signalR.transports.common.js" />1370(function ($, window, undefined) {1371 var signalR = $.signalR,1372 events = $.signalR.events,1373 changeState = $.signalR.changeState,1374 transportLogic = signalR.transports._logic;1375 signalR.transports.webSockets = {1376 name: "webSockets",1377 supportsKeepAlive: function () {1378 return true;1379 },1380 send: function (connection, data) {1381 var payload = transportLogic.stringifySend(connection, data);1382 try {1383 connection.socket.send(payload);1384 } catch (ex) {1385 $(connection).triggerHandler(events.onError,1386 [signalR._.transportError(1387 signalR.resources.webSocketsInvalidState,1388 connection.transport,1389 ex,1390 connection.socket1391 ),1392 data]);1393 }1394 },1395 start: function (connection, onSuccess, onFailed) {1396 var url,1397 opened = false,1398 that = this,1399 reconnecting = !onSuccess,1400 $connection = $(connection);1401 if (!window.WebSocket) {1402 onFailed();1403 return;1404 }1405 if (!connection.socket) {1406 if (connection.webSocketServerUrl) {1407 url = connection.webSocketServerUrl;1408 } else {1409 url = connection.wsProtocol + connection.host;1410 }1411 url += transportLogic.getUrl(connection, this.name, reconnecting);1412 connection.log("Connecting to websocket endpoint '" + url + "'.");1413 connection.socket = new window.WebSocket(url);1414 connection.socket.onopen = function () {1415 opened = true;1416 connection.log("Websocket opened.");1417 transportLogic.clearReconnectTimeout(connection);1418 if (changeState(connection,1419 signalR.connectionState.reconnecting,1420 signalR.connectionState.connected) === true) {1421 $connection.triggerHandler(events.onReconnect);1422 }1423 };1424 connection.socket.onclose = function (event) {1425 var error;1426 // Only handle a socket close if the close is from the current socket.1427 // Sometimes on disconnect the server will push down an onclose event1428 // to an expired socket.1429 if (this === connection.socket) {1430 if (opened && typeof event.wasClean !== "undefined" && event.wasClean === false) {1431 // Ideally this would use the websocket.onerror handler (rather than checking wasClean in onclose) but1432 // I found in some circumstances Chrome won't call onerror. This implementation seems to work on all browsers.1433 error = signalR._.transportError(1434 signalR.resources.webSocketClosed,1435 connection.transport,1436 event);1437 connection.log("Unclean disconnect from websocket: " + (event.reason || "[no reason given]."));1438 } else {1439 connection.log("Websocket closed.");1440 }1441 if (!onFailed || !onFailed(error)) {1442 if (error) {1443 $(connection).triggerHandler(events.onError, [error]);1444 }1445 that.reconnect(connection);1446 }1447 }1448 };1449 connection.socket.onmessage = function (event) {1450 var data;1451 try {1452 data = connection._parseResponse(event.data);1453 }1454 catch (error) {1455 transportLogic.handleParseFailure(connection, event.data, error, onFailed, event);1456 return;1457 }1458 if (data) {1459 // data.M is PersistentResponse.Messages1460 if ($.isEmptyObject(data) || data.M) {1461 transportLogic.processMessages(connection, data, onSuccess);1462 } else {1463 // For websockets we need to trigger onReceived1464 // for callbacks to outgoing hub calls.1465 transportLogic.triggerReceived(connection, data);1466 }1467 }1468 };1469 }1470 },1471 reconnect: function (connection) {1472 transportLogic.reconnect(connection, this.name);1473 },1474 lostConnection: function (connection) {1475 this.reconnect(connection);1476 },1477 stop: function (connection) {1478 // Don't trigger a reconnect after stopping1479 transportLogic.clearReconnectTimeout(connection);1480 if (connection.socket) {1481 connection.log("Closing the Websocket.");1482 connection.socket.close();1483 connection.socket = null;1484 }1485 },1486 abort: function (connection, async) {1487 transportLogic.ajaxAbort(connection, async);1488 }1489 };1490}(window.jQuery, window));1491/* jquery.signalR.transports.serverSentEvents.js */1492// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.md in the project root for license information.1493/*global window:false */1494/// <reference path="jquery.signalR.transports.common.js" />1495(function ($, window, undefined) {1496 var signalR = $.signalR,1497 events = $.signalR.events,1498 changeState = $.signalR.changeState,1499 transportLogic = signalR.transports._logic,1500 clearReconnectAttemptTimeout = function (connection) {1501 window.clearTimeout(connection._.reconnectAttemptTimeoutHandle);1502 delete connection._.reconnectAttemptTimeoutHandle;1503 };1504 signalR.transports.serverSentEvents = {1505 name: "serverSentEvents",1506 supportsKeepAlive: function () {1507 return true;1508 },1509 timeOut: 3000,1510 start: function (connection, onSuccess, onFailed) {1511 var that = this,1512 opened = false,1513 $connection = $(connection),1514 reconnecting = !onSuccess,1515 url;1516 if (connection.eventSource) {1517 connection.log("The connection already has an event source. Stopping it.");1518 connection.stop();1519 }1520 if (!window.EventSource) {1521 if (onFailed) {1522 connection.log("This browser doesn't support SSE.");1523 onFailed();1524 }1525 return;1526 }1527 url = transportLogic.getUrl(connection, this.name, reconnecting);1528 try {1529 connection.log("Attempting to connect to SSE endpoint '" + url + "'.");1530 connection.eventSource = new window.EventSource(url, { withCredentials: connection.withCredentials });1531 }1532 catch (e) {1533 connection.log("EventSource failed trying to connect with error " + e.Message + ".");1534 if (onFailed) {1535 // The connection failed, call the failed callback1536 onFailed();1537 } else {1538 $connection.triggerHandler(events.onError, [signalR._.transportError(signalR.resources.eventSourceFailedToConnect, connection.transport, e)]);1539 if (reconnecting) {1540 // If we were reconnecting, rather than doing initial connect, then try reconnect again1541 that.reconnect(connection);1542 }1543 }1544 return;1545 }1546 if (reconnecting) {1547 connection._.reconnectAttemptTimeoutHandle = window.setTimeout(function () {1548 if (opened === false) {1549 // If we're reconnecting and the event source is attempting to connect,1550 // don't keep retrying. This causes duplicate connections to spawn.1551 if (connection.eventSource.readyState !== window.EventSource.OPEN) {1552 // If we were reconnecting, rather than doing initial connect, then try reconnect again1553 that.reconnect(connection);1554 }1555 }1556 },1557 that.timeOut);1558 }1559 connection.eventSource.addEventListener("open", function (e) {1560 connection.log("EventSource connected.");1561 clearReconnectAttemptTimeout(connection);1562 transportLogic.clearReconnectTimeout(connection);1563 if (opened === false) {1564 opened = true;1565 if (changeState(connection,1566 signalR.connectionState.reconnecting,1567 signalR.connectionState.connected) === true) {1568 $connection.triggerHandler(events.onReconnect);1569 }1570 }1571 }, false);1572 connection.eventSource.addEventListener("message", function (e) {1573 var res;1574 // process messages1575 if (e.data === "initialized") {1576 return;1577 }1578 try {1579 res = connection._parseResponse(e.data);1580 }1581 catch (error) {1582 transportLogic.handleParseFailure(connection, e.data, error, onFailed, e);1583 return;1584 }1585 transportLogic.processMessages(connection, res, onSuccess);1586 }, false);1587 connection.eventSource.addEventListener("error", function (e) {1588 var error = signalR._.transportError(1589 signalR.resources.eventSourceError,1590 connection.transport,1591 e);1592 // Only handle an error if the error is from the current Event Source.1593 // Sometimes on disconnect the server will push down an error event1594 // to an expired Event Source.1595 if (this !== connection.eventSource) {1596 return;1597 }1598 if (onFailed && onFailed(error)) {1599 return;1600 }1601 connection.log("EventSource readyState: " + connection.eventSource.readyState + ".");1602 if (e.eventPhase === window.EventSource.CLOSED) {1603 // We don't use the EventSource's native reconnect function as it1604 // doesn't allow us to change the URL when reconnecting. We need1605 // to change the URL to not include the /connect suffix, and pass1606 // the last message id we received.1607 connection.log("EventSource reconnecting due to the server connection ending.");1608 that.reconnect(connection);1609 } else {1610 // connection error1611 connection.log("EventSource error.");1612 $connection.triggerHandler(events.onError, [error]);1613 }1614 }, false);1615 },1616 reconnect: function (connection) {1617 transportLogic.reconnect(connection, this.name);1618 },1619 lostConnection: function (connection) {1620 this.reconnect(connection);1621 },1622 send: function (connection, data) {1623 transportLogic.ajaxSend(connection, data);1624 },1625 stop: function (connection) {1626 // Don't trigger a reconnect after stopping1627 clearReconnectAttemptTimeout(connection);1628 transportLogic.clearReconnectTimeout(connection);1629 if (connection && connection.eventSource) {1630 connection.log("EventSource calling close().");1631 connection.eventSource.close();1632 connection.eventSource = null;1633 delete connection.eventSource;1634 }1635 },1636 abort: function (connection, async) {1637 transportLogic.ajaxAbort(connection, async);1638 }1639 };1640}(window.jQuery, window));1641/* jquery.signalR.transports.foreverFrame.js */1642// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.md in the project root for license information.1643/*global window:false */1644/// <reference path="jquery.signalR.transports.common.js" />1645(function ($, window, undefined) {1646 var signalR = $.signalR,1647 events = $.signalR.events,1648 changeState = $.signalR.changeState,1649 transportLogic = signalR.transports._logic,1650 createFrame = function () {1651 var frame = window.document.createElement("iframe");1652 frame.setAttribute("style", "position:absolute;top:0;left:0;width:0;height:0;visibility:hidden;");1653 return frame;1654 },1655 // Used to prevent infinite loading icon spins in older versions of ie1656 // We build this object inside a closure so we don't pollute the rest of 1657 // the foreverFrame transport with unnecessary functions/utilities.1658 loadPreventer = (function () {1659 var loadingFixIntervalId = null,1660 loadingFixInterval = 1000,1661 attachedTo = 0;1662 return {1663 prevent: function () {1664 // Prevent additional iframe removal procedures from newer browsers1665 if (signalR._.ieVersion <= 8) {1666 // We only ever want to set the interval one time, so on the first attachedTo1667 if (attachedTo === 0) {1668 // Create and destroy iframe every 3 seconds to prevent loading icon, super hacky1669 loadingFixIntervalId = window.setInterval(function () {1670 var tempFrame = createFrame();1671 window.document.body.appendChild(tempFrame);1672 window.document.body.removeChild(tempFrame);1673 tempFrame = null;1674 }, loadingFixInterval);1675 }1676 attachedTo++;1677 }1678 },1679 cancel: function () {1680 // Only clear the interval if there's only one more object that the loadPreventer is attachedTo1681 if (attachedTo === 1) {1682 window.clearInterval(loadingFixIntervalId);1683 }1684 if (attachedTo > 0) {1685 attachedTo--;1686 }1687 }1688 };1689 })();1690 signalR.transports.foreverFrame = {1691 name: "foreverFrame",1692 supportsKeepAlive: function () {1693 return true;1694 },1695 // Added as a value here so we can create tests to verify functionality1696 iframeClearThreshold: 50,1697 start: function (connection, onSuccess, onFailed) {1698 var that = this,1699 frameId = (transportLogic.foreverFrame.count += 1),1700 url,1701 frame = createFrame(),1702 frameLoadHandler = function () {1703 connection.log("Forever frame iframe finished loading and is no longer receiving messages.");1704 if (!onFailed || !onFailed()) {1705 that.reconnect(connection);1706 }1707 };1708 if (window.EventSource) {1709 // If the browser supports SSE, don't use Forever Frame1710 if (onFailed) {1711 connection.log("Forever Frame is not supported by SignalR on browsers with SSE support.");1712 onFailed();1713 }1714 return;1715 }1716 frame.setAttribute("data-signalr-connection-id", connection.id);1717 // Start preventing loading icon1718 // This will only perform work if the loadPreventer is not attached to another connection.1719 loadPreventer.prevent();1720 // Build the url1721 url = transportLogic.getUrl(connection, this.name);1722 url += "&frameId=" + frameId;1723 // add frame to the document prior to setting URL to avoid caching issues.1724 window.document.documentElement.appendChild(frame);1725 connection.log("Binding to iframe's load event.");1726 if (frame.addEventListener) {1727 frame.addEventListener("load", frameLoadHandler, false);1728 } else if (frame.attachEvent) {1729 frame.attachEvent("onload", frameLoadHandler);1730 }1731 frame.src = url;1732 transportLogic.foreverFrame.connections[frameId] = connection;1733 connection.frame = frame;1734 connection.frameId = frameId;1735 if (onSuccess) {1736 connection.onSuccess = function () {1737 connection.log("Iframe transport started.");1738 onSuccess();1739 };1740 }1741 },1742 reconnect: function (connection) {1743 var that = this;1744 // Need to verify connection state and verify before the setTimeout occurs because an application sleep could occur during the setTimeout duration.1745 if (transportLogic.isConnectedOrReconnecting(connection) && transportLogic.verifyLastActive(connection)) {1746 window.setTimeout(function () {1747 // Verify that we're ok to reconnect.1748 if (!transportLogic.verifyLastActive(connection)) {1749 return;1750 }1751 if (connection.frame && transportLogic.ensureReconnectingState(connection)) {1752 var frame = connection.frame,1753 src = transportLogic.getUrl(connection, that.name, true) + "&frameId=" + connection.frameId;1754 connection.log("Updating iframe src to '" + src + "'.");1755 frame.src = src;1756 }1757 }, connection.reconnectDelay);1758 }1759 },1760 lostConnection: function (connection) {1761 this.reconnect(connection);1762 },1763 send: function (connection, data) {1764 transportLogic.ajaxSend(connection, data);1765 },1766 receive: function (connection, data) {1767 var cw,1768 body,1769 response;1770 if (connection.json !== connection._originalJson) {1771 // If there's a custom JSON parser configured then serialize the object1772 // using the original (browser) JSON parser and then deserialize it using1773 // the custom parser (connection._parseResponse does that). This is so we1774 // can easily send the response from the server as "raw" JSON but still 1775 // support custom JSON deserialization in the browser.1776 data = connection._originalJson.stringify(data);1777 }1778 response = connection._parseResponse(data);1779 transportLogic.processMessages(connection, response, connection.onSuccess);1780 // Protect against connection stopping from a callback trigger within the processMessages above.1781 if (connection.state === $.signalR.connectionState.connected) {1782 // Delete the script & div elements1783 connection.frameMessageCount = (connection.frameMessageCount || 0) + 1;1784 if (connection.frameMessageCount > signalR.transports.foreverFrame.iframeClearThreshold) {1785 connection.frameMessageCount = 0;1786 cw = connection.frame.contentWindow || connection.frame.contentDocument;1787 if (cw && cw.document && cw.document.body) {1788 body = cw.document.body;1789 // Remove all the child elements from the iframe's body to conserver memory1790 while (body.firstChild) {1791 body.removeChild(body.firstChild);1792 }1793 }1794 }1795 }1796 },1797 stop: function (connection) {1798 var cw = null;1799 // Stop attempting to prevent loading icon1800 loadPreventer.cancel();1801 if (connection.frame) {1802 if (connection.frame.stop) {1803 connection.frame.stop();1804 } else {1805 try {1806 cw = connection.frame.contentWindow || connection.frame.contentDocument;1807 if (cw.document && cw.document.execCommand) {1808 cw.document.execCommand("Stop");1809 }1810 }1811 catch (e) {1812 connection.log("Error occured when stopping foreverFrame transport. Message = " + e.message + ".");1813 }1814 }1815 // Ensure the iframe is where we left it1816 if (connection.frame.parentNode === window.document.body) {1817 window.document.body.removeChild(connection.frame);1818 }1819 delete transportLogic.foreverFrame.connections[connection.frameId];1820 connection.frame = null;1821 connection.frameId = null;1822 delete connection.frame;1823 delete connection.frameId;1824 delete connection.onSuccess;1825 delete connection.frameMessageCount;1826 connection.log("Stopping forever frame.");1827 }1828 },1829 abort: function (connection, async) {1830 transportLogic.ajaxAbort(connection, async);1831 },1832 getConnection: function (id) {1833 return transportLogic.foreverFrame.connections[id];1834 },1835 started: function (connection) {1836 if (changeState(connection,1837 signalR.connectionState.reconnecting,1838 signalR.connectionState.connected) === true) {1839 $(connection).triggerHandler(events.onReconnect);1840 }1841 }1842 };1843}(window.jQuery, window));1844/* jquery.signalR.transports.longPolling.js */1845// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.md in the project root for license information.1846/*global window:false */1847/// <reference path="jquery.signalR.transports.common.js" />1848(function ($, window, undefined) {1849 var signalR = $.signalR,1850 events = $.signalR.events,1851 changeState = $.signalR.changeState,1852 isDisconnecting = $.signalR.isDisconnecting,1853 transportLogic = signalR.transports._logic;1854 signalR.transports.longPolling = {1855 name: "longPolling",1856 supportsKeepAlive: function () {1857 return false;1858 },1859 reconnectDelay: 3000,1860 start: function (connection, onSuccess, onFailed) {1861 /// <summary>Starts the long polling connection</summary>1862 /// <param name="connection" type="signalR">The SignalR connection to start</param>1863 var that = this,1864 fireConnect = function () {1865 fireConnect = $.noop;1866 connection.log("LongPolling connected.");1867 onSuccess();1868 },1869 tryFailConnect = function (error) {1870 if (onFailed(error)) {1871 connection.log("LongPolling failed to connect.");1872 return true;1873 }1874 return false;1875 },1876 privateData = connection._,1877 reconnectErrors = 0,1878 fireReconnected = function (instance) {1879 window.clearTimeout(privateData.reconnectTimeoutId);1880 privateData.reconnectTimeoutId = null;1881 if (changeState(instance,1882 signalR.connectionState.reconnecting,1883 signalR.connectionState.connected) === true) {1884 // Successfully reconnected!1885 instance.log("Raising the reconnect event");1886 $(instance).triggerHandler(events.onReconnect);1887 }1888 },1889 // 1 hour1890 maxFireReconnectedTimeout = 3600000;1891 if (connection.pollXhr) {1892 connection.log("Polling xhr requests already exists, aborting.");1893 connection.stop();1894 }1895 connection.messageId = null;1896 privateData.reconnectTimeoutId = null;1897 privateData.pollTimeoutId = window.setTimeout(function () {1898 (function poll(instance, raiseReconnect) {1899 var messageId = instance.messageId,1900 connect = (messageId === null),1901 reconnecting = !connect,1902 polling = !raiseReconnect,1903 url = transportLogic.getUrl(instance, that.name, reconnecting, polling, true /* use Post for longPolling */),1904 postData = {};1905 if (instance.messageId) {1906 postData.messageId = instance.messageId;1907 }1908 if (instance.groupsToken) {1909 postData.groupsToken = instance.groupsToken;1910 }1911 // If we've disconnected during the time we've tried to re-instantiate the poll then stop.1912 if (isDisconnecting(instance) === true) {1913 return;1914 }1915 connection.log("Opening long polling request to '" + url + "'.");1916 instance.pollXhr = transportLogic.ajax(connection, {1917 xhrFields: {1918 onprogress: function () {1919 transportLogic.markLastMessage(connection);1920 }1921 },1922 url: url,1923 type: "POST",1924 contentType: signalR._.defaultContentType,1925 data: postData,1926 timeout: connection._.pollTimeout,1927 success: function (result) {1928 var minData,1929 delay = 0,1930 data,1931 shouldReconnect;1932 connection.log("Long poll complete.");1933 // Reset our reconnect errors so if we transition into a reconnecting state again we trigger1934 // reconnected quickly1935 reconnectErrors = 0;1936 try {1937 // Remove any keep-alives from the beginning of the result1938 minData = connection._parseResponse(result);1939 }1940 catch (error) {1941 transportLogic.handleParseFailure(instance, result, error, tryFailConnect, instance.pollXhr);1942 return;1943 }1944 // If there's currently a timeout to trigger reconnect, fire it now before processing messages1945 if (privateData.reconnectTimeoutId !== null) {1946 fireReconnected(instance);1947 }1948 if (minData) {1949 data = transportLogic.maximizePersistentResponse(minData);1950 }1951 transportLogic.processMessages(instance, minData, fireConnect);1952 if (data &&1953 $.type(data.LongPollDelay) === "number") {1954 delay = data.LongPollDelay;1955 }1956 if (isDisconnecting(instance) === true) {1957 return;1958 }1959 shouldReconnect = data && data.ShouldReconnect;1960 if (shouldReconnect) {1961 // Transition into the reconnecting state1962 // If this fails then that means that the user transitioned the connection into a invalid state in processMessages.1963 if (!transportLogic.ensureReconnectingState(instance)) {1964 return;1965 }1966 }1967 // We never want to pass a raiseReconnect flag after a successful poll. This is handled via the error function1968 if (delay > 0) {1969 privateData.pollTimeoutId = window.setTimeout(function () {1970 poll(instance, shouldReconnect);1971 }, delay);1972 } else {1973 poll(instance, shouldReconnect);1974 }1975 },1976 error: function (data, textStatus) {1977 var error = signalR._.transportError(signalR.resources.longPollFailed, connection.transport, data, instance.pollXhr);1978 // Stop trying to trigger reconnect, connection is in an error state1979 // If we're not in the reconnect state this will noop1980 window.clearTimeout(privateData.reconnectTimeoutId);1981 privateData.reconnectTimeoutId = null;1982 if (textStatus === "abort") {1983 connection.log("Aborted xhr request.");1984 return;1985 }1986 if (!tryFailConnect(error)) {1987 // Increment our reconnect errors, we assume all errors to be reconnect errors1988 // In the case that it's our first error this will cause Reconnect to be fired1989 // after 1 second due to reconnectErrors being = 1.1990 reconnectErrors++;1991 if (connection.state !== signalR.connectionState.reconnecting) {1992 connection.log("An error occurred using longPolling. Status = " + textStatus + ". Response = " + data.responseText + ".");1993 $(instance).triggerHandler(events.onError, [error]);1994 }1995 // We check the state here to verify that we're not in an invalid state prior to verifying Reconnect.1996 // If we're not in connected or reconnecting then the next ensureReconnectingState check will fail and will return.1997 // Therefore we don't want to change that failure code path.1998 if ((connection.state === signalR.connectionState.connected ||1999 connection.state === signalR.connectionState.reconnecting) &&2000 !transportLogic.verifyLastActive(connection)) {2001 return;2002 }2003 // Transition into the reconnecting state2004 // If this fails then that means that the user transitioned the connection into the disconnected or connecting state within the above error handler trigger.2005 if (!transportLogic.ensureReconnectingState(instance)) {2006 return;2007 }2008 // Call poll with the raiseReconnect flag as true after the reconnect delay2009 privateData.pollTimeoutId = window.setTimeout(function () {2010 poll(instance, true);2011 }, that.reconnectDelay);2012 }2013 }2014 });2015 // This will only ever pass after an error has occured via the poll ajax procedure.2016 if (reconnecting && raiseReconnect === true) {2017 // We wait to reconnect depending on how many times we've failed to reconnect.2018 // This is essentially a heuristic that will exponentially increase in wait time before2019 // triggering reconnected. This depends on the "error" handler of Poll to cancel this 2020 // timeout if it triggers before the Reconnected event fires.2021 // The Math.min at the end is to ensure that the reconnect timeout does not overflow.2022 privateData.reconnectTimeoutId = window.setTimeout(function () { fireReconnected(instance); }, Math.min(1000 * (Math.pow(2, reconnectErrors) - 1), maxFireReconnectedTimeout));2023 }2024 }(connection));2025 }, 250); // Have to delay initial poll so Chrome doesn't show loader spinner in tab2026 },2027 lostConnection: function (connection) {2028 if (connection.pollXhr) {2029 connection.pollXhr.abort("lostConnection");2030 }2031 },2032 send: function (connection, data) {2033 transportLogic.ajaxSend(connection, data);2034 },2035 stop: function (connection) {2036 /// <summary>Stops the long polling connection</summary>2037 /// <param name="connection" type="signalR">The SignalR connection to stop</param>2038 window.clearTimeout(connection._.pollTimeoutId);2039 window.clearTimeout(connection._.reconnectTimeoutId);2040 delete connection._.pollTimeoutId;2041 delete connection._.reconnectTimeoutId;2042 if (connection.pollXhr) {2043 connection.pollXhr.abort();2044 connection.pollXhr = null;2045 delete connection.pollXhr;2046 }2047 },2048 abort: function (connection, async) {2049 transportLogic.ajaxAbort(connection, async);2050 }2051 };2052}(window.jQuery, window));2053/* jquery.signalR.hubs.js */2054// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.md in the project root for license information.2055/*global window:false */2056/// <reference path="jquery.signalR.core.js" />2057(function ($, window, undefined) {2058 var eventNamespace = ".hubProxy",2059 signalR = $.signalR;2060 function makeEventName(event) {2061 return event + eventNamespace;2062 }2063 // Equivalent to Array.prototype.map2064 function map(arr, fun, thisp) {2065 var i,2066 length = arr.length,2067 result = [];2068 for (i = 0; i < length; i += 1) {2069 if (arr.hasOwnProperty(i)) {2070 result[i] = fun.call(thisp, arr[i], i, arr);2071 }2072 }2073 return result;2074 }2075 function getArgValue(a) {2076 return $.isFunction(a) ? null : ($.type(a) === "undefined" ? null : a);2077 }2078 function hasMembers(obj) {2079 for (var key in obj) {2080 // If we have any properties in our callback map then we have callbacks and can exit the loop via return2081 if (obj.hasOwnProperty(key)) {2082 return true;2083 }2084 }2085 return false;2086 }2087 function clearInvocationCallbacks(connection, error) {2088 /// <param name="connection" type="hubConnection" />2089 var callbacks = connection._.invocationCallbacks,2090 callback;2091 if (hasMembers(callbacks)) {2092 connection.log("Clearing hub invocation callbacks with error: " + error + ".");2093 }2094 // Reset the callback cache now as we have a local var referencing it2095 connection._.invocationCallbackId = 0;2096 delete connection._.invocationCallbacks;2097 connection._.invocationCallbacks = {};2098 // Loop over the callbacks and invoke them.2099 // We do this using a local var reference and *after* we've cleared the cache2100 // so that if a fail callback itself tries to invoke another method we don't 2101 // end up with its callback in the list we're looping over.2102 for (var callbackId in callbacks) {2103 callback = callbacks[callbackId];2104 callback.method.call(callback.scope, { E: error });2105 }2106 }2107 // hubProxy2108 function hubProxy(hubConnection, hubName) {2109 /// <summary>2110 /// Creates a new proxy object for the given hub connection that can be used to invoke2111 /// methods on server hubs and handle client method invocation requests from the server.2112 /// </summary>2113 return new hubProxy.fn.init(hubConnection, hubName);2114 }2115 hubProxy.fn = hubProxy.prototype = {2116 init: function (connection, hubName) {2117 this.state = {};2118 this.connection = connection;2119 this.hubName = hubName;2120 this._ = {2121 callbackMap: {}2122 };2123 },2124 constructor: hubProxy,2125 hasSubscriptions: function () {2126 return hasMembers(this._.callbackMap);2127 },2128 on: function (eventName, callback) {2129 /// <summary>Wires up a callback to be invoked when a invocation request is received from the server hub.</summary>2130 /// <param name="eventName" type="String">The name of the hub event to register the callback for.</param>2131 /// <param name="callback" type="Function">The callback to be invoked.</param>2132 var that = this,2133 callbackMap = that._.callbackMap;2134 // Normalize the event name to lowercase2135 eventName = eventName.toLowerCase();2136 // If there is not an event registered for this callback yet we want to create its event space in the callback map.2137 if (!callbackMap[eventName]) {2138 callbackMap[eventName] = {};2139 }2140 // Map the callback to our encompassed function2141 callbackMap[eventName][callback] = function (e, data) {2142 callback.apply(that, data);2143 };2144 $(that).bind(makeEventName(eventName), callbackMap[eventName][callback]);2145 return that;2146 },2147 off: function (eventName, callback) {2148 /// <summary>Removes the callback invocation request from the server hub for the given event name.</summary>2149 /// <param name="eventName" type="String">The name of the hub event to unregister the callback for.</param>2150 /// <param name="callback" type="Function">The callback to be invoked.</param>2151 var that = this,2152 callbackMap = that._.callbackMap,2153 callbackSpace;2154 // Normalize the event name to lowercase2155 eventName = eventName.toLowerCase();2156 callbackSpace = callbackMap[eventName];2157 // Verify that there is an event space to unbind2158 if (callbackSpace) {2159 // Only unbind if there's an event bound with eventName and a callback with the specified callback2160 if (callbackSpace[callback]) {2161 $(that).unbind(makeEventName(eventName), callbackSpace[callback]);2162 // Remove the callback from the callback map2163 delete callbackSpace[callback];2164 // Check if there are any members left on the event, if not we need to destroy it.2165 if (!hasMembers(callbackSpace)) {2166 delete callbackMap[eventName];2167 }2168 } else if (!callback) { // Check if we're removing the whole event and we didn't error because of an invalid callback2169 $(that).unbind(makeEventName(eventName));2170 delete callbackMap[eventName];2171 }2172 }2173 return that;2174 },2175 invoke: function (methodName) {2176 /// <summary>Invokes a server hub method with the given arguments.</summary>2177 /// <param name="methodName" type="String">The name of the server hub method.</param>2178 var that = this,2179 connection = that.connection,2180 args = $.makeArray(arguments).slice(1),2181 argValues = map(args, getArgValue),2182 data = { H: that.hubName, M: methodName, A: argValues, I: connection._.invocationCallbackId },2183 d = $.Deferred(),2184 callback = function (minResult) {2185 var result = that._maximizeHubResponse(minResult),2186 source,2187 error;2188 // Update the hub state2189 $.extend(that.state, result.State);2190 if (result.Progress) {2191 if (d.notifyWith) {2192 // Progress is only supported in jQuery 1.7+2193 d.notifyWith(that, [result.Progress.Data]);2194 } else if(!connection._.progressjQueryVersionLogged) {2195 connection.log("A hub method invocation progress update was received but the version of jQuery in use (" + $.prototype.jquery + ") does not support progress updates. Upgrade to jQuery 1.7+ to receive progress notifications.");2196 connection._.progressjQueryVersionLogged = true;2197 }2198 } else if (result.Error) {2199 // Server hub method threw an exception, log it & reject the deferred2200 if (result.StackTrace) {2201 connection.log(result.Error + "\n" + result.StackTrace + ".");2202 }2203 // result.ErrorData is only set if a HubException was thrown2204 source = result.IsHubException ? "HubException" : "Exception";2205 error = signalR._.error(result.Error, source);2206 error.data = result.ErrorData;2207 connection.log(that.hubName + "." + methodName + " failed to execute. Error: " + error.message);2208 d.rejectWith(that, [error]);2209 } else {2210 // Server invocation succeeded, resolve the deferred2211 connection.log("Invoked " + that.hubName + "." + methodName);2212 d.resolveWith(that, [result.Result]);2213 }2214 };2215 connection._.invocationCallbacks[connection._.invocationCallbackId.toString()] = { scope: that, method: callback };2216 connection._.invocationCallbackId += 1;2217 if (!$.isEmptyObject(that.state)) {2218 data.S = that.state;2219 }2220 connection.log("Invoking " + that.hubName + "." + methodName);2221 connection.send(data);2222 return d.promise();2223 },2224 _maximizeHubResponse: function (minHubResponse) {2225 return {2226 State: minHubResponse.S,2227 Result: minHubResponse.R,2228 Progress: minHubResponse.P ? {2229 Id: minHubResponse.P.I,2230 Data: minHubResponse.P.D2231 } : null,2232 Id: minHubResponse.I,2233 IsHubException: minHubResponse.H,2234 Error: minHubResponse.E,2235 StackTrace: minHubResponse.T,2236 ErrorData: minHubResponse.D2237 };2238 }2239 };2240 hubProxy.fn.init.prototype = hubProxy.fn;2241 // hubConnection2242 function hubConnection(url, options) {2243 /// <summary>Creates a new hub connection.</summary>2244 /// <param name="url" type="String">[Optional] The hub route url, defaults to "/signalr".</param>2245 /// <param name="options" type="Object">[Optional] Settings to use when creating the hubConnection.</param>2246 var settings = {2247 qs: null,2248 logging: false,2249 useDefaultPath: true2250 };2251 $.extend(settings, options);2252 if (!url || settings.useDefaultPath) {2253 url = (url || "") + "/signalr";2254 }2255 return new hubConnection.fn.init(url, settings);2256 }...

Full Screen

Full Screen

jquery.signalR-1.1.2.js

Source:jquery.signalR-1.1.2.js Github

copy

Full Screen

...587 // Check if the keep alive has completely timed out588 if (timeElapsed >= keepAliveData.timeout) {589 connection.log("Keep alive timed out. Notifying transport that connection has been lost.");590 // Notify transport that the connection has been lost591 connection.transport.lostConnection(connection);592 }593 else if (timeElapsed >= keepAliveData.timeoutWarning) {594 // This is to assure that the user only gets a single warning595 if (!keepAliveData.userNotified) {596 connection.log("Keep alive has been missed, connection may be dead/slow.");597 $(connection).triggerHandler(events.onConnectionSlow);598 keepAliveData.userNotified = true;599 }600 }601 else {602 keepAliveData.userNotified = false;603 }604 }605 // Verify we're monitoring the keep alive606 // We don't want this as a part of the inner if statement above because we want keep alives to continue to be checked607 // in the event that the server comes back online (if it goes offline).608 if (keepAliveData.monitoring) {609 window.setTimeout(function () {610 checkIfAlive(connection);611 }, keepAliveData.checkInterval);612 }613 }614 function isConnectedOrReconnecting(connection) {615 return connection.state === signalR.connectionState.connected ||616 connection.state === signalR.connectionState.reconnecting;617 }618 signalR.transports._logic = {619 pingServer: function (connection, transport) {620 /// <summary>Pings the server</summary>621 /// <param name="connection" type="signalr">Connection associated with the server ping</param>622 /// <returns type="signalR" />623 var baseUrl = transport === "webSockets" ? "" : connection.baseUrl,624 url = baseUrl + connection.appRelativeUrl + "/ping",625 deferral = $.Deferred();626 url = this.addQs(url, connection);627 $.ajax({628 url: url,629 global: false,630 cache: false,631 type: "GET",632 contentType: connection.contentType,633 data: {},634 dataType: connection.ajaxDataType,635 success: function (data) {636 if (data.Response === "pong") {637 deferral.resolve();638 }639 else {640 deferral.reject("SignalR: Invalid ping response when pinging server: " + (data.responseText || data.statusText));641 }642 },643 error: function (data) {644 deferral.reject("SignalR: Error pinging server: " + (data.responseText || data.statusText));645 }646 });647 return deferral.promise();648 },649 addQs: function (url, connection) {650 var appender = url.indexOf("?") !== -1 ? "&" : "?",651 firstChar;652 if (!connection.qs) {653 return url;654 }655 if (typeof (connection.qs) === "object") {656 return url + appender + $.param(connection.qs);657 }658 if (typeof (connection.qs) === "string") {659 firstChar = connection.qs.charAt(0);660 if (firstChar === "?" || firstChar === "&") {661 appender = "";662 }663 return url + appender + connection.qs;664 }665 throw new Error("Connections query string property must be either a string or object.");666 },667 getUrl: function (connection, transport, reconnecting, poll) {668 /// <summary>Gets the url for making a GET based connect request</summary>669 var baseUrl = transport === "webSockets" ? "" : connection.baseUrl,670 url = baseUrl + connection.appRelativeUrl,671 qs = "transport=" + transport + "&connectionToken=" + window.encodeURIComponent(connection.token);672 if (connection.data) {673 qs += "&connectionData=" + window.encodeURIComponent(connection.data);674 }675 if (connection.groupsToken) {676 qs += "&groupsToken=" + window.encodeURIComponent(connection.groupsToken);677 }678 if (!reconnecting) {679 url += "/connect";680 } else {681 if (poll) {682 // longPolling transport specific683 url += "/poll";684 } else {685 url += "/reconnect";686 }687 if (connection.messageId) {688 qs += "&messageId=" + window.encodeURIComponent(connection.messageId);689 }690 }691 url += "?" + qs;692 url = this.addQs(url, connection);693 url += "&tid=" + Math.floor(Math.random() * 11);694 return url;695 },696 maximizePersistentResponse: function (minPersistentResponse) {697 return {698 MessageId: minPersistentResponse.C,699 Messages: minPersistentResponse.M,700 Disconnect: typeof (minPersistentResponse.D) !== "undefined" ? true : false,701 TimedOut: typeof (minPersistentResponse.T) !== "undefined" ? true : false,702 LongPollDelay: minPersistentResponse.L,703 GroupsToken: minPersistentResponse.G704 };705 },706 updateGroups: function (connection, groupsToken) {707 if (groupsToken) {708 connection.groupsToken = groupsToken;709 }710 },711 ajaxSend: function (connection, data) {712 var url = connection.url + "/send" + "?transport=" + connection.transport.name + "&connectionToken=" + window.encodeURIComponent(connection.token);713 url = this.addQs(url, connection);714 return $.ajax({715 url: url,716 global: false,717 type: connection.ajaxDataType === "jsonp" ? "GET" : "POST",718 contentType: signalR._.defaultContentType,719 dataType: connection.ajaxDataType,720 data: {721 data: data722 },723 success: function (result) {724 if (result) {725 $(connection).triggerHandler(events.onReceived, [result]);726 }727 },728 error: function (errData, textStatus) {729 if (textStatus === "abort" || textStatus === "parsererror") {730 // The parsererror happens for sends that don't return any data, and hence731 // don't write the jsonp callback to the response. This is harder to fix on the server732 // so just hack around it on the client for now.733 return;734 }735 $(connection).triggerHandler(events.onError, [errData]);736 }737 });738 },739 ajaxAbort: function (connection, async) {740 if (typeof (connection.transport) === "undefined") {741 return;742 }743 // Async by default unless explicitly overidden744 async = typeof async === "undefined" ? true : async;745 var url = connection.url + "/abort" + "?transport=" + connection.transport.name + "&connectionToken=" + window.encodeURIComponent(connection.token);746 url = this.addQs(url, connection);747 $.ajax({748 url: url,749 async: async,750 timeout: 1000,751 global: false,752 type: "POST",753 contentType: connection.contentType,754 dataType: connection.ajaxDataType,755 data: {}756 });757 connection.log("Fired ajax abort async = " + async);758 },759 processMessages: function (connection, minData) {760 var data;761 // Transport can be null if we've just closed the connection762 if (connection.transport) {763 var $connection = $(connection);764 // If our transport supports keep alive then we need to update the last keep alive time stamp.765 // Very rarely the transport can be null.766 if (connection.transport.supportsKeepAlive && connection.keepAliveData.activated) {767 this.updateKeepAlive(connection);768 }769 if (!minData) {770 return;771 }772 data = this.maximizePersistentResponse(minData);773 if (data.Disconnect) {774 connection.log("Disconnect command received from server");775 // Disconnected by the server776 connection.stop(false, false);777 return;778 }779 this.updateGroups(connection, data.GroupsToken);780 if (data.Messages) {781 $.each(data.Messages, function (index, message) {782 $connection.triggerHandler(events.onReceived, [message]);783 });784 }785 if (data.MessageId) {786 connection.messageId = data.MessageId;787 }788 }789 },790 monitorKeepAlive: function (connection) {791 var keepAliveData = connection.keepAliveData,792 that = this;793 // If we haven't initiated the keep alive timeouts then we need to794 if (!keepAliveData.monitoring) {795 keepAliveData.monitoring = true;796 // Initialize the keep alive time stamp ping797 that.updateKeepAlive(connection);798 // Save the function so we can unbind it on stop799 connection.keepAliveData.reconnectKeepAliveUpdate = function () {800 that.updateKeepAlive(connection);801 };802 // Update Keep alive on reconnect803 $(connection).bind(events.onReconnect, connection.keepAliveData.reconnectKeepAliveUpdate);804 connection.log("Now monitoring keep alive with a warning timeout of " + keepAliveData.timeoutWarning + " and a connection lost timeout of " + keepAliveData.timeout);805 // Start the monitoring of the keep alive806 checkIfAlive(connection);807 }808 else {809 connection.log("Tried to monitor keep alive but it's already being monitored");810 }811 },812 stopMonitoringKeepAlive: function (connection) {813 var keepAliveData = connection.keepAliveData;814 // Only attempt to stop the keep alive monitoring if its being monitored815 if (keepAliveData.monitoring) {816 // Stop monitoring817 keepAliveData.monitoring = false;818 // Remove the updateKeepAlive function from the reconnect event819 $(connection).unbind(events.onReconnect, connection.keepAliveData.reconnectKeepAliveUpdate);820 // Clear all the keep alive data821 connection.keepAliveData = {};822 connection.log("Stopping the monitoring of the keep alive");823 }824 },825 updateKeepAlive: function (connection) {826 connection.keepAliveData.lastKeepAlive = new Date();827 },828 ensureReconnectingState: function (connection) {829 if (changeState(connection,830 signalR.connectionState.connected,831 signalR.connectionState.reconnecting) === true) {832 $(connection).triggerHandler(events.onReconnecting);833 }834 return connection.state === signalR.connectionState.reconnecting;835 },836 clearReconnectTimeout: function (connection) {837 if (connection && connection._.reconnectTimeout) {838 window.clearTimeout(connection._.reconnectTimeout);839 delete connection._.reconnectTimeout;840 }841 },842 reconnect: function (connection, transportName) {843 var transport = signalR.transports[transportName],844 that = this;845 // We should only set a reconnectTimeout if we are currently connected846 // and a reconnectTimeout isn't already set.847 if (isConnectedOrReconnecting(connection) && !connection._.reconnectTimeout) {848 connection._.reconnectTimeout = window.setTimeout(function () {849 transport.stop(connection);850 if (that.ensureReconnectingState(connection)) {851 connection.log(transportName + " reconnecting");852 transport.start(connection);853 }854 }, connection.reconnectDelay);855 }856 },857 foreverFrame: {858 count: 0,859 connections: {}860 }861 };862}(window.jQuery, window));863/* jquery.signalR.transports.webSockets.js */864// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.md in the project root for license information.865/*global window:false */866/// <reference path="jquery.signalR.transports.common.js" />867(function ($, window) {868 "use strict";869 var signalR = $.signalR,870 events = $.signalR.events,871 changeState = $.signalR.changeState,872 transportLogic = signalR.transports._logic;873 signalR.transports.webSockets = {874 name: "webSockets",875 supportsKeepAlive: true,876 send: function (connection, data) {877 connection.socket.send(data);878 },879 start: function (connection, onSuccess, onFailed) {880 var url,881 opened = false,882 that = this,883 reconnecting = !onSuccess,884 $connection = $(connection);885 if (!window.WebSocket) {886 onFailed();887 return;888 }889 if (!connection.socket) {890 if (connection.webSocketServerUrl) {891 url = connection.webSocketServerUrl;892 }893 else {894 url = connection.wsProtocol + connection.host;895 }896 url += transportLogic.getUrl(connection, this.name, reconnecting);897 connection.log("Connecting to websocket endpoint '" + url + "'");898 connection.socket = new window.WebSocket(url);899 connection.socket.onopen = function () {900 opened = true;901 connection.log("Websocket opened");902 transportLogic.clearReconnectTimeout(connection);903 if (onSuccess) {904 onSuccess();905 } else if (changeState(connection,906 signalR.connectionState.reconnecting,907 signalR.connectionState.connected) === true) {908 $connection.triggerHandler(events.onReconnect);909 }910 };911 connection.socket.onclose = function (event) {912 // Only handle a socket close if the close is from the current socket.913 // Sometimes on disconnect the server will push down an onclose event914 // to an expired socket.915 if (this === connection.socket) {916 if (!opened) {917 if (onFailed) {918 onFailed();919 }920 else if (reconnecting) {921 that.reconnect(connection);922 }923 return;924 }925 else if (typeof event.wasClean !== "undefined" && event.wasClean === false) {926 // Ideally this would use the websocket.onerror handler (rather than checking wasClean in onclose) but927 // I found in some circumstances Chrome won't call onerror. This implementation seems to work on all browsers.928 $(connection).triggerHandler(events.onError, [event.reason]);929 connection.log("Unclean disconnect from websocket." + event.reason);930 }931 else {932 connection.log("Websocket closed");933 }934 that.reconnect(connection);935 }936 };937 connection.socket.onmessage = function (event) {938 var data = window.JSON.parse(event.data),939 $connection = $(connection);940 if (data) {941 // data.M is PersistentResponse.Messages942 if ($.isEmptyObject(data) || data.M) {943 transportLogic.processMessages(connection, data);944 } else {945 // For websockets we need to trigger onReceived946 // for callbacks to outgoing hub calls.947 $connection.triggerHandler(events.onReceived, [data]);948 }949 }950 };951 }952 },953 reconnect: function (connection) {954 transportLogic.reconnect(connection, this.name);955 },956 lostConnection: function (connection) {957 this.reconnect(connection);958 },959 stop: function (connection) {960 // Don't trigger a reconnect after stopping961 transportLogic.clearReconnectTimeout(connection);962 if (connection.socket !== null) {963 connection.log("Closing the Websocket");964 connection.socket.close();965 connection.socket = null;966 }967 },968 abort: function (connection) {969 }970 };971}(window.jQuery, window));972/* jquery.signalR.transports.serverSentEvents.js */973// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.md in the project root for license information.974/*global window:false */975/// <reference path="jquery.signalR.transports.common.js" />976(function ($, window) {977 "use strict";978 var signalR = $.signalR,979 events = $.signalR.events,980 changeState = $.signalR.changeState,981 transportLogic = signalR.transports._logic;982 signalR.transports.serverSentEvents = {983 name: "serverSentEvents",984 supportsKeepAlive: true,985 timeOut: 3000,986 start: function (connection, onSuccess, onFailed) {987 var that = this,988 opened = false,989 $connection = $(connection),990 reconnecting = !onSuccess,991 url,992 connectTimeOut;993 if (connection.eventSource) {994 connection.log("The connection already has an event source. Stopping it.");995 connection.stop();996 }997 if (!window.EventSource) {998 if (onFailed) {999 connection.log("This browser doesn't support SSE.");1000 onFailed();1001 }1002 return;1003 }1004 url = transportLogic.getUrl(connection, this.name, reconnecting);1005 try {1006 connection.log("Attempting to connect to SSE endpoint '" + url + "'");1007 connection.eventSource = new window.EventSource(url);1008 }1009 catch (e) {1010 connection.log("EventSource failed trying to connect with error " + e.Message);1011 if (onFailed) {1012 // The connection failed, call the failed callback1013 onFailed();1014 }1015 else {1016 $connection.triggerHandler(events.onError, [e]);1017 if (reconnecting) {1018 // If we were reconnecting, rather than doing initial connect, then try reconnect again1019 that.reconnect(connection);1020 }1021 }1022 return;1023 }1024 // After connecting, if after the specified timeout there's no response stop the connection1025 // and raise on failed1026 connectTimeOut = window.setTimeout(function () {1027 if (opened === false) {1028 connection.log("EventSource timed out trying to connect");1029 connection.log("EventSource readyState: " + connection.eventSource.readyState);1030 if (!reconnecting) {1031 that.stop(connection);1032 }1033 if (reconnecting) {1034 // If we're reconnecting and the event source is attempting to connect,1035 // don't keep retrying. This causes duplicate connections to spawn.1036 if (connection.eventSource.readyState !== window.EventSource.CONNECTING &&1037 connection.eventSource.readyState !== window.EventSource.OPEN) {1038 // If we were reconnecting, rather than doing initial connect, then try reconnect again1039 that.reconnect(connection);1040 }1041 } else if (onFailed) {1042 onFailed();1043 }1044 }1045 },1046 that.timeOut);1047 connection.eventSource.addEventListener("open", function (e) {1048 connection.log("EventSource connected");1049 if (connectTimeOut) {1050 window.clearTimeout(connectTimeOut);1051 }1052 transportLogic.clearReconnectTimeout(connection);1053 if (opened === false) {1054 opened = true;1055 if (onSuccess) {1056 onSuccess();1057 } else if (changeState(connection,1058 signalR.connectionState.reconnecting,1059 signalR.connectionState.connected) === true) {1060 // If there's no onSuccess handler we assume this is a reconnect1061 $connection.triggerHandler(events.onReconnect);1062 }1063 }1064 }, false);1065 connection.eventSource.addEventListener("message", function (e) {1066 // process messages1067 if (e.data === "initialized") {1068 return;1069 }1070 transportLogic.processMessages(connection, window.JSON.parse(e.data));1071 }, false);1072 connection.eventSource.addEventListener("error", function (e) {1073 // Only handle an error if the error is from the current Event Source.1074 // Sometimes on disconnect the server will push down an error event1075 // to an expired Event Source.1076 if (this === connection.eventSource) {1077 if (!opened) {1078 if (onFailed) {1079 onFailed();1080 }1081 return;1082 }1083 connection.log("EventSource readyState: " + connection.eventSource.readyState);1084 if (e.eventPhase === window.EventSource.CLOSED) {1085 // We don't use the EventSource's native reconnect function as it1086 // doesn't allow us to change the URL when reconnecting. We need1087 // to change the URL to not include the /connect suffix, and pass1088 // the last message id we received.1089 connection.log("EventSource reconnecting due to the server connection ending");1090 that.reconnect(connection);1091 } else {1092 // connection error1093 connection.log("EventSource error");1094 $connection.triggerHandler(events.onError);1095 }1096 }1097 }, false);1098 },1099 reconnect: function (connection) {1100 transportLogic.reconnect(connection, this.name);1101 },1102 lostConnection: function (connection) {1103 this.reconnect(connection);1104 },1105 send: function (connection, data) {1106 transportLogic.ajaxSend(connection, data);1107 },1108 stop: function (connection) {1109 // Don't trigger a reconnect after stopping1110 transportLogic.clearReconnectTimeout(connection);1111 if (connection && connection.eventSource) {1112 connection.log("EventSource calling close()");1113 connection.eventSource.close();1114 connection.eventSource = null;1115 delete connection.eventSource;1116 }1117 },1118 abort: function (connection, async) {1119 transportLogic.ajaxAbort(connection, async);1120 }1121 };1122}(window.jQuery, window));1123/* jquery.signalR.transports.foreverFrame.js */1124// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.md in the project root for license information.1125/*global window:false */1126/// <reference path="jquery.signalR.transports.common.js" />1127(function ($, window) {1128 "use strict";1129 var signalR = $.signalR,1130 events = $.signalR.events,1131 changeState = $.signalR.changeState,1132 transportLogic = signalR.transports._logic,1133 // Used to prevent infinite loading icon spins in older versions of ie1134 // We build this object inside a closure so we don't pollute the rest of 1135 // the foreverFrame transport with unnecessary functions/utilities.1136 loadPreventer = (function () {1137 var loadingFixIntervalId = null,1138 loadingFixInterval = 1000,1139 attachedTo = 0;1140 return {1141 prevent: function () {1142 // Prevent additional iframe removal procedures from newer browsers1143 if (signalR._.ieVersion <= 8) {1144 // We only ever want to set the interval one time, so on the first attachedTo1145 if (attachedTo === 0) {1146 // Create and destroy iframe every 3 seconds to prevent loading icon, super hacky1147 loadingFixIntervalId = window.setInterval(function () {1148 var tempFrame = $("<iframe style='position:absolute;top:0;left:0;width:0;height:0;visibility:hidden;' src=''></iframe>");1149 $("body").append(tempFrame);1150 tempFrame.remove();1151 tempFrame = null;1152 }, loadingFixInterval);1153 }1154 attachedTo++;1155 }1156 },1157 cancel: function () { 1158 // Only clear the interval if there's only one more object that the loadPreventer is attachedTo1159 if (attachedTo === 1) {1160 window.clearInterval(loadingFixIntervalId);1161 }1162 if (attachedTo > 0) {1163 attachedTo--;1164 }1165 }1166 };1167 })();1168 signalR.transports.foreverFrame = {1169 name: "foreverFrame",1170 supportsKeepAlive: true,1171 timeOut: 3000,1172 start: function (connection, onSuccess, onFailed) {1173 var that = this,1174 frameId = (transportLogic.foreverFrame.count += 1),1175 url,1176 frame = $("<iframe data-signalr-connection-id='" + connection.id + "' style='position:absolute;top:0;left:0;width:0;height:0;visibility:hidden;' src=''></iframe>");1177 if (window.EventSource) {1178 // If the browser supports SSE, don't use Forever Frame1179 if (onFailed) {1180 connection.log("This browser supports SSE, skipping Forever Frame.");1181 onFailed();1182 }1183 return;1184 }1185 // Start preventing loading icon1186 // This will only perform work if the loadPreventer is not attached to another connection.1187 loadPreventer.prevent();1188 // Build the url1189 url = transportLogic.getUrl(connection, this.name);1190 url += "&frameId=" + frameId;1191 // Set body prior to setting URL to avoid caching issues.1192 $("body").append(frame);1193 frame.prop("src", url);1194 transportLogic.foreverFrame.connections[frameId] = connection;1195 connection.log("Binding to iframe's readystatechange event.");1196 frame.bind("readystatechange", function () {1197 if ($.inArray(this.readyState, ["loaded", "complete"]) >= 0) {1198 connection.log("Forever frame iframe readyState changed to " + this.readyState + ", reconnecting");1199 that.reconnect(connection);1200 }1201 });1202 connection.frame = frame[0];1203 connection.frameId = frameId;1204 if (onSuccess) {1205 connection.onSuccess = onSuccess;1206 }1207 // After connecting, if after the specified timeout there's no response stop the connection1208 // and raise on failed1209 window.setTimeout(function () {1210 if (connection.onSuccess) {1211 connection.log("Failed to connect using forever frame source, it timed out after " + that.timeOut + "ms.");1212 that.stop(connection);1213 if (onFailed) {1214 onFailed();1215 }1216 }1217 }, that.timeOut);1218 },1219 reconnect: function (connection) {1220 var that = this;1221 window.setTimeout(function () {1222 if (connection.frame && transportLogic.ensureReconnectingState(connection)) {1223 var frame = connection.frame,1224 src = transportLogic.getUrl(connection, that.name, true) + "&frameId=" + connection.frameId;1225 connection.log("Updating iframe src to '" + src + "'.");1226 frame.src = src;1227 }1228 }, connection.reconnectDelay);1229 },1230 lostConnection: function (connection) {1231 this.reconnect(connection);1232 },1233 send: function (connection, data) {1234 transportLogic.ajaxSend(connection, data);1235 },1236 receive: function (connection, data) {1237 var cw;1238 transportLogic.processMessages(connection, data);1239 // Delete the script & div elements1240 connection.frameMessageCount = (connection.frameMessageCount || 0) + 1;1241 if (connection.frameMessageCount > 50) {1242 connection.frameMessageCount = 0;1243 cw = connection.frame.contentWindow || connection.frame.contentDocument;1244 if (cw && cw.document) {1245 $("body", cw.document).empty();1246 }1247 }1248 },1249 stop: function (connection) {1250 var cw = null;1251 // Stop attempting to prevent loading icon1252 loadPreventer.cancel();1253 if (connection.frame) {1254 if (connection.frame.stop) {1255 connection.frame.stop();1256 } else {1257 try {1258 cw = connection.frame.contentWindow || connection.frame.contentDocument;1259 if (cw.document && cw.document.execCommand) {1260 cw.document.execCommand("Stop");1261 }1262 }1263 catch (e) {1264 connection.log("SignalR: Error occured when stopping foreverFrame transport. Message = " + e.message);1265 }1266 }1267 $(connection.frame).remove();1268 delete transportLogic.foreverFrame.connections[connection.frameId];1269 connection.frame = null;1270 connection.frameId = null;1271 delete connection.frame;1272 delete connection.frameId;1273 connection.log("Stopping forever frame");1274 }1275 },1276 abort: function (connection, async) {1277 transportLogic.ajaxAbort(connection, async);1278 },1279 getConnection: function (id) {1280 return transportLogic.foreverFrame.connections[id];1281 },1282 started: function (connection) {1283 if (connection.onSuccess) {1284 connection.onSuccess();1285 connection.onSuccess = null;1286 delete connection.onSuccess;1287 } else if (changeState(connection,1288 signalR.connectionState.reconnecting,1289 signalR.connectionState.connected) === true) {1290 // If there's no onSuccess handler we assume this is a reconnect1291 $(connection).triggerHandler(events.onReconnect);1292 }1293 }1294 };1295}(window.jQuery, window));1296/* jquery.signalR.transports.longPolling.js */1297// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.md in the project root for license information.1298/*global window:false */1299/// <reference path="jquery.signalR.transports.common.js" />1300(function ($, window) {1301 "use strict";1302 var signalR = $.signalR,1303 events = $.signalR.events,1304 changeState = $.signalR.changeState,1305 isDisconnecting = $.signalR.isDisconnecting,1306 transportLogic = signalR.transports._logic;1307 signalR.transports.longPolling = {1308 name: "longPolling",1309 supportsKeepAlive: false,1310 reconnectDelay: 3000,1311 init: function (connection, onComplete) {1312 /// <su