@microsoft/signalr
Version:
ASP.NET Core SignalR Client
952 lines • 50.5 kB
JavaScript
"use strict";
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
var HandshakeProtocol_1 = require("./HandshakeProtocol");
var IHubProtocol_1 = require("./IHubProtocol");
var ILogger_1 = require("./ILogger");
var Subject_1 = require("./Subject");
var Utils_1 = require("./Utils");
var DEFAULT_TIMEOUT_IN_MS = 30 * 1000;
var DEFAULT_PING_INTERVAL_IN_MS = 15 * 1000;
/** Describes the current state of the {@link HubConnection} to the server. */
var HubConnectionState;
(function (HubConnectionState) {
/** The hub connection is disconnected. */
HubConnectionState["Disconnected"] = "Disconnected";
/** The hub connection is connecting. */
HubConnectionState["Connecting"] = "Connecting";
/** The hub connection is connected. */
HubConnectionState["Connected"] = "Connected";
/** The hub connection is disconnecting. */
HubConnectionState["Disconnecting"] = "Disconnecting";
/** The hub connection is reconnecting. */
HubConnectionState["Reconnecting"] = "Reconnecting";
})(HubConnectionState = exports.HubConnectionState || (exports.HubConnectionState = {}));
/** Represents a connection to a SignalR Hub. */
var HubConnection = /** @class */ (function () {
function HubConnection(connection, logger, protocol, reconnectPolicy) {
var _this = this;
this.nextKeepAlive = 0;
Utils_1.Arg.isRequired(connection, "connection");
Utils_1.Arg.isRequired(logger, "logger");
Utils_1.Arg.isRequired(protocol, "protocol");
this.serverTimeoutInMilliseconds = DEFAULT_TIMEOUT_IN_MS;
this.keepAliveIntervalInMilliseconds = DEFAULT_PING_INTERVAL_IN_MS;
this.logger = logger;
this.protocol = protocol;
this.connection = connection;
this.reconnectPolicy = reconnectPolicy;
this.handshakeProtocol = new HandshakeProtocol_1.HandshakeProtocol();
this.connection.onreceive = function (data) { return _this.processIncomingData(data); };
this.connection.onclose = function (error) { return _this.connectionClosed(error); };
this.callbacks = {};
this.methods = {};
this.closedCallbacks = [];
this.reconnectingCallbacks = [];
this.reconnectedCallbacks = [];
this.invocationId = 0;
this.receivedHandshakeResponse = false;
this.connectionState = HubConnectionState.Disconnected;
this.connectionStarted = false;
this.cachedPingMessage = this.protocol.writeMessage({ type: IHubProtocol_1.MessageType.Ping });
}
/** @internal */
// Using a public static factory method means we can have a private constructor and an _internal_
// create method that can be used by HubConnectionBuilder. An "internal" constructor would just
// be stripped away and the '.d.ts' file would have no constructor, which is interpreted as a
// public parameter-less constructor.
HubConnection.create = function (connection, logger, protocol, reconnectPolicy) {
return new HubConnection(connection, logger, protocol, reconnectPolicy);
};
Object.defineProperty(HubConnection.prototype, "state", {
/** Indicates the state of the {@link HubConnection} to the server. */
get: function () {
return this.connectionState;
},
enumerable: true,
configurable: true
});
Object.defineProperty(HubConnection.prototype, "connectionId", {
/** Represents the connection id of the {@link HubConnection} on the server. The connection id will be null when the connection is either
* in the disconnected state or if the negotiation step was skipped.
*/
get: function () {
return this.connection ? (this.connection.connectionId || null) : null;
},
enumerable: true,
configurable: true
});
Object.defineProperty(HubConnection.prototype, "baseUrl", {
/** Indicates the url of the {@link HubConnection} to the server. */
get: function () {
return this.connection.baseUrl || "";
},
/**
* Sets a new url for the HubConnection. Note that the url can only be changed when the connection is in either the Disconnected or
* Reconnecting states.
* @param {string} url The url to connect to.
*/
set: function (url) {
if (this.connectionState !== HubConnectionState.Disconnected && this.connectionState !== HubConnectionState.Reconnecting) {
throw new Error("The HubConnection must be in the Disconnected or Reconnecting state to change the url.");
}
if (!url) {
throw new Error("The HubConnection url must be a valid url.");
}
this.connection.baseUrl = url;
},
enumerable: true,
configurable: true
});
/** Starts the connection.
*
* @returns {Promise<void>} A Promise that resolves when the connection has been successfully established, or rejects with an error.
*/
HubConnection.prototype.start = function () {
this.startPromise = this.startWithStateTransitions();
return this.startPromise;
};
HubConnection.prototype.startWithStateTransitions = function () {
return __awaiter(this, void 0, void 0, function () {
var e_1;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (this.connectionState !== HubConnectionState.Disconnected) {
return [2 /*return*/, Promise.reject(new Error("Cannot start a HubConnection that is not in the 'Disconnected' state."))];
}
this.connectionState = HubConnectionState.Connecting;
this.logger.log(ILogger_1.LogLevel.Debug, "Starting HubConnection.");
_a.label = 1;
case 1:
_a.trys.push([1, 3, , 4]);
return [4 /*yield*/, this.startInternal()];
case 2:
_a.sent();
this.connectionState = HubConnectionState.Connected;
this.connectionStarted = true;
this.logger.log(ILogger_1.LogLevel.Debug, "HubConnection connected successfully.");
return [3 /*break*/, 4];
case 3:
e_1 = _a.sent();
this.connectionState = HubConnectionState.Disconnected;
this.logger.log(ILogger_1.LogLevel.Debug, "HubConnection failed to start successfully because of error '" + e_1 + "'.");
return [2 /*return*/, Promise.reject(e_1)];
case 4: return [2 /*return*/];
}
});
});
};
HubConnection.prototype.startInternal = function () {
return __awaiter(this, void 0, void 0, function () {
var handshakePromise, handshakeRequest, e_2;
var _this = this;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
this.stopDuringStartError = undefined;
this.receivedHandshakeResponse = false;
handshakePromise = new Promise(function (resolve, reject) {
_this.handshakeResolver = resolve;
_this.handshakeRejecter = reject;
});
return [4 /*yield*/, this.connection.start(this.protocol.transferFormat)];
case 1:
_a.sent();
_a.label = 2;
case 2:
_a.trys.push([2, 5, , 7]);
handshakeRequest = {
protocol: this.protocol.name,
version: this.protocol.version,
};
this.logger.log(ILogger_1.LogLevel.Debug, "Sending handshake request.");
return [4 /*yield*/, this.sendMessage(this.handshakeProtocol.writeHandshakeRequest(handshakeRequest))];
case 3:
_a.sent();
this.logger.log(ILogger_1.LogLevel.Information, "Using HubProtocol '" + this.protocol.name + "'.");
// defensively cleanup timeout in case we receive a message from the server before we finish start
this.cleanupTimeout();
this.resetTimeoutPeriod();
this.resetKeepAliveInterval();
return [4 /*yield*/, handshakePromise];
case 4:
_a.sent();
// It's important to check the stopDuringStartError instead of just relying on the handshakePromise
// being rejected on close, because this continuation can run after both the handshake completed successfully
// and the connection was closed.
if (this.stopDuringStartError) {
// It's important to throw instead of returning a rejected promise, because we don't want to allow any state
// transitions to occur between now and the calling code observing the exceptions. Returning a rejected promise
// will cause the calling continuation to get scheduled to run later.
throw this.stopDuringStartError;
}
return [3 /*break*/, 7];
case 5:
e_2 = _a.sent();
this.logger.log(ILogger_1.LogLevel.Debug, "Hub handshake failed with error '" + e_2 + "' during start(). Stopping HubConnection.");
this.cleanupTimeout();
this.cleanupPingTimer();
// HttpConnection.stop() should not complete until after the onclose callback is invoked.
// This will transition the HubConnection to the disconnected state before HttpConnection.stop() completes.
return [4 /*yield*/, this.connection.stop(e_2)];
case 6:
// HttpConnection.stop() should not complete until after the onclose callback is invoked.
// This will transition the HubConnection to the disconnected state before HttpConnection.stop() completes.
_a.sent();
throw e_2;
case 7: return [2 /*return*/];
}
});
});
};
/** Stops the connection.
*
* @returns {Promise<void>} A Promise that resolves when the connection has been successfully terminated, or rejects with an error.
*/
HubConnection.prototype.stop = function () {
return __awaiter(this, void 0, void 0, function () {
var startPromise, e_3;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
startPromise = this.startPromise;
this.stopPromise = this.stopInternal();
return [4 /*yield*/, this.stopPromise];
case 1:
_a.sent();
_a.label = 2;
case 2:
_a.trys.push([2, 4, , 5]);
// Awaiting undefined continues immediately
return [4 /*yield*/, startPromise];
case 3:
// Awaiting undefined continues immediately
_a.sent();
return [3 /*break*/, 5];
case 4:
e_3 = _a.sent();
return [3 /*break*/, 5];
case 5: return [2 /*return*/];
}
});
});
};
HubConnection.prototype.stopInternal = function (error) {
if (this.connectionState === HubConnectionState.Disconnected) {
this.logger.log(ILogger_1.LogLevel.Debug, "Call to HubConnection.stop(" + error + ") ignored because it is already in the disconnected state.");
return Promise.resolve();
}
if (this.connectionState === HubConnectionState.Disconnecting) {
this.logger.log(ILogger_1.LogLevel.Debug, "Call to HttpConnection.stop(" + error + ") ignored because the connection is already in the disconnecting state.");
return this.stopPromise;
}
this.connectionState = HubConnectionState.Disconnecting;
this.logger.log(ILogger_1.LogLevel.Debug, "Stopping HubConnection.");
if (this.reconnectDelayHandle) {
// We're in a reconnect delay which means the underlying connection is currently already stopped.
// Just clear the handle to stop the reconnect loop (which no one is waiting on thankfully) and
// fire the onclose callbacks.
this.logger.log(ILogger_1.LogLevel.Debug, "Connection stopped during reconnect delay. Done reconnecting.");
clearTimeout(this.reconnectDelayHandle);
this.reconnectDelayHandle = undefined;
this.completeClose();
return Promise.resolve();
}
this.cleanupTimeout();
this.cleanupPingTimer();
this.stopDuringStartError = error || new Error("The connection was stopped before the hub handshake could complete.");
// HttpConnection.stop() should not complete until after either HttpConnection.start() fails
// or the onclose callback is invoked. The onclose callback will transition the HubConnection
// to the disconnected state if need be before HttpConnection.stop() completes.
return this.connection.stop(error);
};
/** Invokes a streaming hub method on the server using the specified name and arguments.
*
* @typeparam T The type of the items returned by the server.
* @param {string} methodName The name of the server method to invoke.
* @param {any[]} args The arguments used to invoke the server method.
* @returns {IStreamResult<T>} An object that yields results from the server as they are received.
*/
HubConnection.prototype.stream = function (methodName) {
var _this = this;
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
var _a = this.replaceStreamingParams(args), streams = _a[0], streamIds = _a[1];
var invocationDescriptor = this.createStreamInvocation(methodName, args, streamIds);
var promiseQueue;
var subject = new Subject_1.Subject();
subject.cancelCallback = function () {
var cancelInvocation = _this.createCancelInvocation(invocationDescriptor.invocationId);
delete _this.callbacks[invocationDescriptor.invocationId];
return promiseQueue.then(function () {
return _this.sendWithProtocol(cancelInvocation);
});
};
this.callbacks[invocationDescriptor.invocationId] = function (invocationEvent, error) {
if (error) {
subject.error(error);
return;
}
else if (invocationEvent) {
// invocationEvent will not be null when an error is not passed to the callback
if (invocationEvent.type === IHubProtocol_1.MessageType.Completion) {
if (invocationEvent.error) {
subject.error(new Error(invocationEvent.error));
}
else {
subject.complete();
}
}
else {
subject.next((invocationEvent.item));
}
}
};
promiseQueue = this.sendWithProtocol(invocationDescriptor)
.catch(function (e) {
subject.error(e);
delete _this.callbacks[invocationDescriptor.invocationId];
});
this.launchStreams(streams, promiseQueue);
return subject;
};
HubConnection.prototype.sendMessage = function (message) {
this.resetKeepAliveInterval();
return this.connection.send(message);
};
/**
* Sends a js object to the server.
* @param message The js object to serialize and send.
*/
HubConnection.prototype.sendWithProtocol = function (message) {
return this.sendMessage(this.protocol.writeMessage(message));
};
/** Invokes a hub method on the server using the specified name and arguments. Does not wait for a response from the receiver.
*
* The Promise returned by this method resolves when the client has sent the invocation to the server. The server may still
* be processing the invocation.
*
* @param {string} methodName The name of the server method to invoke.
* @param {any[]} args The arguments used to invoke the server method.
* @returns {Promise<void>} A Promise that resolves when the invocation has been successfully sent, or rejects with an error.
*/
HubConnection.prototype.send = function (methodName) {
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
var _a = this.replaceStreamingParams(args), streams = _a[0], streamIds = _a[1];
var sendPromise = this.sendWithProtocol(this.createInvocation(methodName, args, true, streamIds));
this.launchStreams(streams, sendPromise);
return sendPromise;
};
/** Invokes a hub method on the server using the specified name and arguments.
*
* The Promise returned by this method resolves when the server indicates it has finished invoking the method. When the promise
* resolves, the server has finished invoking the method. If the server method returns a result, it is produced as the result of
* resolving the Promise.
*
* @typeparam T The expected return type.
* @param {string} methodName The name of the server method to invoke.
* @param {any[]} args The arguments used to invoke the server method.
* @returns {Promise<T>} A Promise that resolves with the result of the server method (if any), or rejects with an error.
*/
HubConnection.prototype.invoke = function (methodName) {
var _this = this;
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
var _a = this.replaceStreamingParams(args), streams = _a[0], streamIds = _a[1];
var invocationDescriptor = this.createInvocation(methodName, args, false, streamIds);
var p = new Promise(function (resolve, reject) {
// invocationId will always have a value for a non-blocking invocation
_this.callbacks[invocationDescriptor.invocationId] = function (invocationEvent, error) {
if (error) {
reject(error);
return;
}
else if (invocationEvent) {
// invocationEvent will not be null when an error is not passed to the callback
if (invocationEvent.type === IHubProtocol_1.MessageType.Completion) {
if (invocationEvent.error) {
reject(new Error(invocationEvent.error));
}
else {
resolve(invocationEvent.result);
}
}
else {
reject(new Error("Unexpected message type: " + invocationEvent.type));
}
}
};
var promiseQueue = _this.sendWithProtocol(invocationDescriptor)
.catch(function (e) {
reject(e);
// invocationId will always have a value for a non-blocking invocation
delete _this.callbacks[invocationDescriptor.invocationId];
});
_this.launchStreams(streams, promiseQueue);
});
return p;
};
/** Registers a handler that will be invoked when the hub method with the specified method name is invoked.
*
* @param {string} methodName The name of the hub method to define.
* @param {Function} newMethod The handler that will be raised when the hub method is invoked.
*/
HubConnection.prototype.on = function (methodName, newMethod) {
if (!methodName || !newMethod) {
return;
}
methodName = methodName.toLowerCase();
if (!this.methods[methodName]) {
this.methods[methodName] = [];
}
// Preventing adding the same handler multiple times.
if (this.methods[methodName].indexOf(newMethod) !== -1) {
return;
}
this.methods[methodName].push(newMethod);
};
HubConnection.prototype.off = function (methodName, method) {
if (!methodName) {
return;
}
methodName = methodName.toLowerCase();
var handlers = this.methods[methodName];
if (!handlers) {
return;
}
if (method) {
var removeIdx = handlers.indexOf(method);
if (removeIdx !== -1) {
handlers.splice(removeIdx, 1);
if (handlers.length === 0) {
delete this.methods[methodName];
}
}
}
else {
delete this.methods[methodName];
}
};
/** Registers a handler that will be invoked when the connection is closed.
*
* @param {Function} callback The handler that will be invoked when the connection is closed. Optionally receives a single argument containing the error that caused the connection to close (if any).
*/
HubConnection.prototype.onclose = function (callback) {
if (callback) {
this.closedCallbacks.push(callback);
}
};
/** Registers a handler that will be invoked when the connection starts reconnecting.
*
* @param {Function} callback The handler that will be invoked when the connection starts reconnecting. Optionally receives a single argument containing the error that caused the connection to start reconnecting (if any).
*/
HubConnection.prototype.onreconnecting = function (callback) {
if (callback) {
this.reconnectingCallbacks.push(callback);
}
};
/** Registers a handler that will be invoked when the connection successfully reconnects.
*
* @param {Function} callback The handler that will be invoked when the connection successfully reconnects.
*/
HubConnection.prototype.onreconnected = function (callback) {
if (callback) {
this.reconnectedCallbacks.push(callback);
}
};
HubConnection.prototype.processIncomingData = function (data) {
this.cleanupTimeout();
if (!this.receivedHandshakeResponse) {
data = this.processHandshakeResponse(data);
this.receivedHandshakeResponse = true;
}
// Data may have all been read when processing handshake response
if (data) {
// Parse the messages
var messages = this.protocol.parseMessages(data, this.logger);
for (var _i = 0, messages_1 = messages; _i < messages_1.length; _i++) {
var message = messages_1[_i];
switch (message.type) {
case IHubProtocol_1.MessageType.Invocation:
this.invokeClientMethod(message);
break;
case IHubProtocol_1.MessageType.StreamItem:
case IHubProtocol_1.MessageType.Completion:
var callback = this.callbacks[message.invocationId];
if (callback) {
if (message.type === IHubProtocol_1.MessageType.Completion) {
delete this.callbacks[message.invocationId];
}
callback(message);
}
break;
case IHubProtocol_1.MessageType.Ping:
// Don't care about pings
break;
case IHubProtocol_1.MessageType.Close:
this.logger.log(ILogger_1.LogLevel.Information, "Close message received from server.");
var error = message.error ? new Error("Server returned an error on close: " + message.error) : undefined;
if (message.allowReconnect === true) {
// It feels wrong not to await connection.stop() here, but processIncomingData is called as part of an onreceive callback which is not async,
// this is already the behavior for serverTimeout(), and HttpConnection.Stop() should catch and log all possible exceptions.
// tslint:disable-next-line:no-floating-promises
this.connection.stop(error);
}
else {
// We cannot await stopInternal() here, but subsequent calls to stop() will await this if stopInternal() is still ongoing.
this.stopPromise = this.stopInternal(error);
}
break;
default:
this.logger.log(ILogger_1.LogLevel.Warning, "Invalid message type: " + message.type + ".");
break;
}
}
}
this.resetTimeoutPeriod();
};
HubConnection.prototype.processHandshakeResponse = function (data) {
var _a;
var responseMessage;
var remainingData;
try {
_a = this.handshakeProtocol.parseHandshakeResponse(data), remainingData = _a[0], responseMessage = _a[1];
}
catch (e) {
var message = "Error parsing handshake response: " + e;
this.logger.log(ILogger_1.LogLevel.Error, message);
var error = new Error(message);
this.handshakeRejecter(error);
throw error;
}
if (responseMessage.error) {
var message = "Server returned handshake error: " + responseMessage.error;
this.logger.log(ILogger_1.LogLevel.Error, message);
var error = new Error(message);
this.handshakeRejecter(error);
throw error;
}
else {
this.logger.log(ILogger_1.LogLevel.Debug, "Server handshake complete.");
}
this.handshakeResolver();
return remainingData;
};
HubConnection.prototype.resetKeepAliveInterval = function () {
if (this.connection.features.inherentKeepAlive) {
return;
}
// Set the time we want the next keep alive to be sent
// Timer will be setup on next message receive
this.nextKeepAlive = new Date().getTime() + this.keepAliveIntervalInMilliseconds;
this.cleanupPingTimer();
};
HubConnection.prototype.resetTimeoutPeriod = function () {
var _this = this;
if (!this.connection.features || !this.connection.features.inherentKeepAlive) {
// Set the timeout timer
this.timeoutHandle = setTimeout(function () { return _this.serverTimeout(); }, this.serverTimeoutInMilliseconds);
// Set keepAlive timer if there isn't one
if (this.pingServerHandle === undefined) {
var nextPing = this.nextKeepAlive - new Date().getTime();
if (nextPing < 0) {
nextPing = 0;
}
// The timer needs to be set from a networking callback to avoid Chrome timer throttling from causing timers to run once a minute
this.pingServerHandle = setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
var _a;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
if (!(this.connectionState === HubConnectionState.Connected)) return [3 /*break*/, 4];
_b.label = 1;
case 1:
_b.trys.push([1, 3, , 4]);
return [4 /*yield*/, this.sendMessage(this.cachedPingMessage)];
case 2:
_b.sent();
return [3 /*break*/, 4];
case 3:
_a = _b.sent();
// We don't care about the error. It should be seen elsewhere in the client.
// The connection is probably in a bad or closed state now, cleanup the timer so it stops triggering
this.cleanupPingTimer();
return [3 /*break*/, 4];
case 4: return [2 /*return*/];
}
});
}); }, nextPing);
}
}
};
HubConnection.prototype.serverTimeout = function () {
// The server hasn't talked to us in a while. It doesn't like us anymore ... :(
// Terminate the connection, but we don't need to wait on the promise. This could trigger reconnecting.
// tslint:disable-next-line:no-floating-promises
this.connection.stop(new Error("Server timeout elapsed without receiving a message from the server."));
};
HubConnection.prototype.invokeClientMethod = function (invocationMessage) {
var _this = this;
var methods = this.methods[invocationMessage.target.toLowerCase()];
if (methods) {
try {
methods.forEach(function (m) { return m.apply(_this, invocationMessage.arguments); });
}
catch (e) {
this.logger.log(ILogger_1.LogLevel.Error, "A callback for the method " + invocationMessage.target.toLowerCase() + " threw error '" + e + "'.");
}
if (invocationMessage.invocationId) {
// This is not supported in v1. So we return an error to avoid blocking the server waiting for the response.
var message = "Server requested a response, which is not supported in this version of the client.";
this.logger.log(ILogger_1.LogLevel.Error, message);
// We don't want to wait on the stop itself.
this.stopPromise = this.stopInternal(new Error(message));
}
}
else {
this.logger.log(ILogger_1.LogLevel.Warning, "No client method with the name '" + invocationMessage.target + "' found.");
}
};
HubConnection.prototype.connectionClosed = function (error) {
this.logger.log(ILogger_1.LogLevel.Debug, "HubConnection.connectionClosed(" + error + ") called while in state " + this.connectionState + ".");
// Triggering this.handshakeRejecter is insufficient because it could already be resolved without the continuation having run yet.
this.stopDuringStartError = this.stopDuringStartError || error || new Error("The underlying connection was closed before the hub handshake could complete.");
// If the handshake is in progress, start will be waiting for the handshake promise, so we complete it.
// If it has already completed, this should just noop.
if (this.handshakeResolver) {
this.handshakeResolver();
}
this.cancelCallbacksWithError(error || new Error("Invocation canceled due to the underlying connection being closed."));
this.cleanupTimeout();
this.cleanupPingTimer();
if (this.connectionState === HubConnectionState.Disconnecting) {
this.completeClose(error);
}
else if (this.connectionState === HubConnectionState.Connected && this.reconnectPolicy) {
// tslint:disable-next-line:no-floating-promises
this.reconnect(error);
}
else if (this.connectionState === HubConnectionState.Connected) {
this.completeClose(error);
}
// If none of the above if conditions were true were called the HubConnection must be in either:
// 1. The Connecting state in which case the handshakeResolver will complete it and stopDuringStartError will fail it.
// 2. The Reconnecting state in which case the handshakeResolver will complete it and stopDuringStartError will fail the current reconnect attempt
// and potentially continue the reconnect() loop.
// 3. The Disconnected state in which case we're already done.
};
HubConnection.prototype.completeClose = function (error) {
var _this = this;
if (this.connectionStarted) {
this.connectionState = HubConnectionState.Disconnected;
this.connectionStarted = false;
try {
this.closedCallbacks.forEach(function (c) { return c.apply(_this, [error]); });
}
catch (e) {
this.logger.log(ILogger_1.LogLevel.Error, "An onclose callback called with error '" + error + "' threw error '" + e + "'.");
}
}
};
HubConnection.prototype.reconnect = function (error) {
return __awaiter(this, void 0, void 0, function () {
var reconnectStartTime, previousReconnectAttempts, retryError, nextRetryDelay, e_4;
var _this = this;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
reconnectStartTime = Date.now();
previousReconnectAttempts = 0;
retryError = error !== undefined ? error : new Error("Attempting to reconnect due to a unknown error.");
nextRetryDelay = this.getNextRetryDelay(previousReconnectAttempts++, 0, retryError);
if (nextRetryDelay === null) {
this.logger.log(ILogger_1.LogLevel.Debug, "Connection not reconnecting because the IRetryPolicy returned null on the first reconnect attempt.");
this.completeClose(error);
return [2 /*return*/];
}
this.connectionState = HubConnectionState.Reconnecting;
if (error) {
this.logger.log(ILogger_1.LogLevel.Information, "Connection reconnecting because of error '" + error + "'.");
}
else {
this.logger.log(ILogger_1.LogLevel.Information, "Connection reconnecting.");
}
if (this.onreconnecting) {
try {
this.reconnectingCallbacks.forEach(function (c) { return c.apply(_this, [error]); });
}
catch (e) {
this.logger.log(ILogger_1.LogLevel.Error, "An onreconnecting callback called with error '" + error + "' threw error '" + e + "'.");
}
// Exit early if an onreconnecting callback called connection.stop().
if (this.connectionState !== HubConnectionState.Reconnecting) {
this.logger.log(ILogger_1.LogLevel.Debug, "Connection left the reconnecting state in onreconnecting callback. Done reconnecting.");
return [2 /*return*/];
}
}
_a.label = 1;
case 1:
if (!(nextRetryDelay !== null)) return [3 /*break*/, 7];
this.logger.log(ILogger_1.LogLevel.Information, "Reconnect attempt number " + previousReconnectAttempts + " will start in " + nextRetryDelay + " ms.");
return [4 /*yield*/, new Promise(function (resolve) {
_this.reconnectDelayHandle = setTimeout(resolve, nextRetryDelay);
})];
case 2:
_a.sent();
this.reconnectDelayHandle = undefined;
if (this.connectionState !== HubConnectionState.Reconnecting) {
this.logger.log(ILogger_1.LogLevel.Debug, "Connection left the reconnecting state during reconnect delay. Done reconnecting.");
return [2 /*return*/];
}
_a.label = 3;
case 3:
_a.trys.push([3, 5, , 6]);
return [4 /*yield*/, this.startInternal()];
case 4:
_a.sent();
this.connectionState = HubConnectionState.Connected;
this.logger.log(ILogger_1.LogLevel.Information, "HubConnection reconnected successfully.");
if (this.onreconnected) {
try {
this.reconnectedCallbacks.forEach(function (c) { return c.apply(_this, [_this.connection.connectionId]); });
}
catch (e) {
this.logger.log(ILogger_1.LogLevel.Error, "An onreconnected callback called with connectionId '" + this.connection.connectionId + "; threw error '" + e + "'.");
}
}
return [2 /*return*/];
case 5:
e_4 = _a.sent();
this.logger.log(ILogger_1.LogLevel.Information, "Reconnect attempt failed because of error '" + e_4 + "'.");
if (this.connectionState !== HubConnectionState.Reconnecting) {
this.logger.log(ILogger_1.LogLevel.Debug, "Connection moved to the '" + this.connectionState + "' from the reconnecting state during reconnect attempt. Done reconnecting.");
// The TypeScript compiler thinks that connectionState must be Connected here. The TypeScript compiler is wrong.
if (this.connectionState === HubConnectionState.Disconnecting) {
this.completeClose();
}
return [2 /*return*/];
}
retryError = e_4 instanceof Error ? e_4 : new Error(e_4.toString());
nextRetryDelay = this.getNextRetryDelay(previousReconnectAttempts++, Date.now() - reconnectStartTime, retryError);
return [3 /*break*/, 6];
case 6: return [3 /*break*/, 1];
case 7:
this.logger.log(ILogger_1.LogLevel.Information, "Reconnect retries have been exhausted after " + (Date.now() - reconnectStartTime) + " ms and " + previousReconnectAttempts + " failed attempts. Connection disconnecting.");
this.completeClose();
return [2 /*return*/];
}
});
});
};
HubConnection.prototype.getNextRetryDelay = function (previousRetryCount, elapsedMilliseconds, retryReason) {
try {
return this.reconnectPolicy.nextRetryDelayInMilliseconds({
elapsedMilliseconds: elapsedMilliseconds,
previousRetryCount: previousRetryCount,
retryReason: retryReason,
});
}
catch (e) {
this.logger.log(ILogger_1.LogLevel.Error, "IRetryPolicy.nextRetryDelayInMilliseconds(" + previousRetryCount + ", " + elapsedMilliseconds + ") threw error '" + e + "'.");
return null;
}
};
HubConnection.prototype.cancelCallbacksWithError = function (error) {
var callbacks = this.callbacks;
this.callbacks = {};
Object.keys(callbacks)
.forEach(function (key) {
var callback = callbacks[key];
callback(null, error);
});
};
HubConnection.prototype.cleanupPingTimer = function () {
if (this.pingServerHandle) {
clearTimeout(this.pingServerHandle);
this.pingServerHandle = undefined;
}
};
HubConnection.prototype.cleanupTimeout = function () {
if (this.timeoutHandle) {
clearTimeout(this.timeoutHandle);
}
};
HubConnection.prototype.createInvocation = function (methodName, args, nonblocking, streamIds) {
if (nonblocking) {
if (streamIds.length !== 0) {
return {
arguments: args,
streamIds: streamIds,
target: methodName,
type: IHubProtocol_1.MessageType.Invocation,
};
}
else {
return {
arguments: args,
target: methodName,
type: IHubProtocol_1.MessageType.Invocation,
};
}
}
else {
var invocationId = this.invocationId;
this.invocationId++;
if (streamIds.length !== 0) {
return {
arguments: args,
invocationId: invocationId.toString(),
streamIds: streamIds,
target: methodName,
type: IHubProtocol_1.MessageType.Invocation,
};
}
else {
return {
arguments: args,
invocationId: invocationId.toString(),
target: methodName,
type: IHubProtocol_1.MessageType.Invocation,
};
}
}
};
HubConnection.prototype.launchStreams = function (streams, promiseQueue) {
var _this = this;
if (streams.length === 0) {
return;
}
// Synchronize stream data so they arrive in-order on the server
if (!promiseQueue) {
promiseQueue = Promise.resolve();
}
var _loop_1 = function (streamId) {
streams[streamId].subscribe({
complete: function () {
promiseQueue = promiseQueue.then(function () { return _this.sendWithProtocol(_this.createCompletionMessage(streamId)); });
},
error: function (err) {
var message;
if (err instanceof Error) {
message = err.message;
}
else if (err && err.toString) {
message = err.toString();
}
else {
message = "Unknown error";
}
promiseQueue = promiseQueue.then(function () { return _this.sendWithProtocol(_this.createCompletionMessage(streamId, message)); });
},
next: function (item) {
promiseQueue = promiseQueue.then(function () { return _this.sendWithProtocol(_this.createStreamItemMessage(streamId, item)); });
},
});
};
// We want to iterate over the keys, since the keys are the stream ids
// tslint:disable-next-line:forin
for (var streamId in streams) {
_loop_1(streamId);
}
};
HubConnection.prototype.replaceStreamingParams = function (args) {
var streams = [];
var streamIds = [];
for (var i = 0; i < args.length; i++) {
var argument = args[i];
if (this.isObservable(argument)) {
var streamId = this.invocationId;
this.invocationId++;
// Store the stream for later use
streams[streamId] = argument;
streamIds.push(streamId.toString());
// remove stream from args
args.splice(i, 1);
}
}
return [streams, streamIds];
};
HubConnection.prototype.isObservable = function (arg) {
// This allows other stream implementations to just work (like rxjs)
return arg && arg.subscribe && typeof arg.subscribe === "function";
};
HubConnection.prototype.createStreamInvocation = function (methodName, args, streamIds) {
var invocationId = this.invocationId;
this.invocationId++;
if (streamIds.length !== 0) {
return {
arguments: args,
invocationId: invocationId.toString(),
streamIds: streamIds,
target: methodName,
type: IHubProtocol_1.MessageType.StreamInvocation,
};
}
else {
return {
arguments: args,
invocationId: invocationId.toString(),
target: methodName,
type: IHubProtocol_1.MessageType.StreamInvocation,
};
}
};
HubConnection.prototype.createCancelInvocation = function (id) {
return {
invocationId: id,
type: IHubProtocol_1.MessageType.CancelInvocation,
};
};
HubConnection.prototype.createStreamItemMessage = function (id, item) {
return {
invocationId: id,
item: item,
type: IHubProtocol_1.MessageType.StreamItem,
};
};
HubConnection.prototype.createCompletionMessage = function (id, error, result) {
if (e