ravendb/dist/Http/NodeSelector.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const ArrayUtil_1 = require("../Utility/ArrayUtil");
const moment = require("moment");
const CurrentIndexAndNode_1 = require("../Http/CurrentIndexAndNode");
const Timer_1 = require("../Primitives/Timer");
const Exceptions_1 = require("../Exceptions");
class NodeSelectorState {
    constructor(topology) {
        this.speedTestMode = 1;
        this.topology = topology;
        this.nodes = topology.nodes;
        this.failures = ArrayUtil_1.ArrayUtil.range(topology.nodes.length, () => 0);
        this.fastestRecords = ArrayUtil_1.ArrayUtil.range(topology.nodes.length, () => 0);
    }
}
class NodeSelector {
    constructor(topology) {
        this._state = new NodeSelectorState(topology);
    }
    getTopology() {
        return this._state.topology;
    }
    onFailedRequest(nodeIndex) {
        const state = this._state;
        if (nodeIndex < 0 || nodeIndex >= state.failures.length) {
            return;
        }
        state.failures[nodeIndex]++;
    }
    onUpdateTopology(topology, forceUpdate = false) {
        if (!topology) {
            return false;
        }
        const stateEtag = this._state.topology.etag || 0;
        const topologyEtag = this._state.topology.etag || 0;
        if (stateEtag >= topologyEtag && !forceUpdate) {
            return false;
        }
        this._state = new NodeSelectorState(topology);
        return true;
    }
    getNodeBySessionId(sessionId) {
        const state = this._state;
        const index = sessionId % state.topology.nodes.length;
        for (let i = index; i < state.failures.length; i++) {
            if (state.failures[i] === 0
                && state.nodes[i].serverRole === "Member") {
                return new CurrentIndexAndNode_1.default(i, state.nodes[i]);
            }
        }
        for (let i = 0; i < index; i++) {
            if (state.failures[i] === 0
                && state.nodes[i].serverRole === "Member") {
                return new CurrentIndexAndNode_1.default(i, state.nodes[i]);
            }
        }
        return this.getPreferredNode();
    }
    getPreferredNode() {
        const state = this._state;
        const stateFailures = state.failures;
        const serverNodes = state.nodes;
        const len = Math.min(serverNodes.length, stateFailures.length);
        for (let i = 0; i < len; i++) {
            if (stateFailures[i] === 0 && serverNodes[i].url) {
                return new CurrentIndexAndNode_1.default(i, serverNodes[i]);
            }
        }
        return NodeSelector._unlikelyEveryoneFaultedChoice(state);
    }
    static _unlikelyEveryoneFaultedChoice(state) {
        if (state.nodes.length === 0) {
            Exceptions_1.throwError("AllTopologyNodesDownException", "There are no nodes in the topology at all.");
        }
        return new CurrentIndexAndNode_1.default(0, state.nodes[0]);
    }
    getFastestNode() {
        const state = this._state;
        if (state.failures[state.fastest] === 0
            && state.nodes[state.fastest].serverRole === "Member") {
            return new CurrentIndexAndNode_1.default(state.fastest, state.nodes[state.fastest]);
        }
        this._switchToSpeedTestPhase();
        return this.getPreferredNode();
    }
    restoreNodeIndex(nodeIndex) {
        const state = this._state;
        if (state.failures.length < nodeIndex) {
            return;
        }
        state.failures[nodeIndex] = 0;
    }
    _throwEmptyTopology() {
        Exceptions_1.throwError("InvalidOperationException", "Empty database topology, this shouldn't happen.");
    }
    _switchToSpeedTestPhase() {
        const state = this._state;
        if (state.speedTestMode === 0) {
            state.speedTestMode = 1;
        }
        else {
            return;
        }
        state.fastestRecords.fill(0);
        state.speedTestMode++;
    }
    inSpeedTestPhase() {
        return this._state.speedTestMode > 1;
    }
    recordFastest(index, node) {
        const state = this._state;
        const stateFastest = state.fastestRecords;
        if (index < 0 || index >= stateFastest.length) {
            return;
        }
        if (node !== state.nodes[index]) {
            return;
        }
        if (++stateFastest[index] >= 10) {
            this._selectFastest(state, index);
        }
        if (++state.speedTestMode <= state.nodes.length * 10) {
            return;
        }
        const maxIndex = NodeSelector._findMaxIndex(state);
        this._selectFastest(state, maxIndex);
    }
    static _findMaxIndex(state) {
        const stateFastest = state.fastestRecords;
        let maxIndex = 0;
        let maxValue = 0;
        for (let i = 0; i < stateFastest.length; i++) {
            if (maxValue >= stateFastest[i]) {
                continue;
            }
            maxIndex = i;
            maxValue = stateFastest[i];
        }
        return maxIndex;
    }
    _selectFastest(state, index) {
        state.fastest = index;
        state.speedTestMode = 0;
        const minuteMs = moment.duration(1, "m").asMilliseconds();
        if (this._updateFastestNodeTimer !== null) {
            this._updateFastestNodeTimer.change(minuteMs);
        }
        else {
            this._updateFastestNodeTimer = new Timer_1.Timer(() => {
                this._switchToSpeedTestPhase();
                return Promise.resolve();
            }, minuteMs);
        }
    }
    scheduleSpeedTest() {
        this._switchToSpeedTestPhase();
    }
}
exports.NodeSelector = NodeSelector;