"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.WeightedRoundRobinLoadBalancingConfig = void 0;
exports.setup = setup;
const connectivity_state_1 = require("./connectivity-state");
const constants_1 = require("./constants");
const duration_1 = require("./duration");
const load_balancer_1 = require("./load-balancer");
const load_balancer_pick_first_1 = require("./load-balancer-pick-first");
const logging = require("./logging");
const orca_1 = require("./orca");
const picker_1 = require("./picker");
const priority_queue_1 = require("./priority-queue");
const subchannel_address_1 = require("./subchannel-address");
const TRACER_NAME = 'weighted_round_robin';
function trace(text) {
logging.trace(constants_1.LogVerbosity.DEBUG, TRACER_NAME, text);
}
const TYPE_NAME = 'weighted_round_robin';
const DEFAULT_OOB_REPORTING_PERIOD_MS = 10000;
const DEFAULT_BLACKOUT_PERIOD_MS = 10000;
const DEFAULT_WEIGHT_EXPIRATION_PERIOD_MS = 3 * 60000;
const DEFAULT_WEIGHT_UPDATE_PERIOD_MS = 1000;
const DEFAULT_ERROR_UTILIZATION_PENALTY = 1;
function validateFieldType(obj, fieldName, expectedType) {
if (fieldName in obj &&
obj[fieldName] !== undefined &&
typeof obj[fieldName] !== expectedType) {
throw new Error(`weighted round robin config ${fieldName} parse error: expected ${expectedType}, got ${typeof obj[fieldName]}`);
}
}
function parseDurationField(obj, fieldName) {
if (fieldName in obj && obj[fieldName] !== undefined && obj[fieldName] !== null) {
let durationObject;
if ((0, duration_1.isDuration)(obj[fieldName])) {
durationObject = obj[fieldName];
}
else if ((0, duration_1.isDurationMessage)(obj[fieldName])) {
durationObject = (0, duration_1.durationMessageToDuration)(obj[fieldName]);
}
else if (typeof obj[fieldName] === 'string') {
const parsedDuration = (0, duration_1.parseDuration)(obj[fieldName]);
if (!parsedDuration) {
throw new Error(`weighted round robin config ${fieldName}: failed to parse duration string ${obj[fieldName]}`);
}
durationObject = parsedDuration;
}
else {
throw new Error(`weighted round robin config ${fieldName}: expected duration, got ${typeof obj[fieldName]}`);
}
return (0, duration_1.durationToMs)(durationObject);
}
return null;
}
class WeightedRoundRobinLoadBalancingConfig {
constructor(enableOobLoadReport, oobLoadReportingPeriodMs, blackoutPeriodMs, weightExpirationPeriodMs, weightUpdatePeriodMs, errorUtilizationPenalty) {
this.enableOobLoadReport = enableOobLoadReport !== null && enableOobLoadReport !== void 0 ? enableOobLoadReport : false;
this.oobLoadReportingPeriodMs = oobLoadReportingPeriodMs !== null && oobLoadReportingPeriodMs !== void 0 ? oobLoadReportingPeriodMs : DEFAULT_OOB_REPORTING_PERIOD_MS;
this.blackoutPeriodMs = blackoutPeriodMs !== null && blackoutPeriodMs !== void 0 ? blackoutPeriodMs : DEFAULT_BLACKOUT_PERIOD_MS;
this.weightExpirationPeriodMs = weightExpirationPeriodMs !== null && weightExpirationPeriodMs !== void 0 ? weightExpirationPeriodMs : DEFAULT_WEIGHT_EXPIRATION_PERIOD_MS;
this.weightUpdatePeriodMs = Math.max(weightUpdatePeriodMs !== null && weightUpdatePeriodMs !== void 0 ? weightUpdatePeriodMs : DEFAULT_WEIGHT_UPDATE_PERIOD_MS, 100);
this.errorUtilizationPenalty = errorUtilizationPenalty !== null && errorUtilizationPenalty !== void 0 ? errorUtilizationPenalty : DEFAULT_ERROR_UTILIZATION_PENALTY;
}
getLoadBalancerName() {
return TYPE_NAME;
}
toJsonObject() {
return {
enable_oob_load_report: this.enableOobLoadReport,
oob_load_reporting_period: (0, duration_1.durationToString)((0, duration_1.msToDuration)(this.oobLoadReportingPeriodMs)),
blackout_period: (0, duration_1.durationToString)((0, duration_1.msToDuration)(this.blackoutPeriodMs)),
weight_expiration_period: (0, duration_1.durationToString)((0, duration_1.msToDuration)(this.weightExpirationPeriodMs)),
weight_update_period: (0, duration_1.durationToString)((0, duration_1.msToDuration)(this.weightUpdatePeriodMs)),
error_utilization_penalty: this.errorUtilizationPenalty
};
}
static createFromJson(obj) {
validateFieldType(obj, 'enable_oob_load_report', 'boolean');
validateFieldType(obj, 'error_utilization_penalty', 'number');
if (obj.error_utilization_penalty < 0) {
throw new Error('weighted round robin config error_utilization_penalty < 0');
}
return new WeightedRoundRobinLoadBalancingConfig(obj.enable_oob_load_report, parseDurationField(obj, 'oob_load_reporting_period'), parseDurationField(obj, 'blackout_period'), parseDurationField(obj, 'weight_expiration_period'), parseDurationField(obj, 'weight_update_period'), obj.error_utilization_penalty);
}
getEnableOobLoadReport() {
return this.enableOobLoadReport;
}
getOobLoadReportingPeriodMs() {
return this.oobLoadReportingPeriodMs;
}
getBlackoutPeriodMs() {
return this.blackoutPeriodMs;
}
getWeightExpirationPeriodMs() {
return this.weightExpirationPeriodMs;
}
getWeightUpdatePeriodMs() {
return this.weightUpdatePeriodMs;
}
getErrorUtilizationPenalty() {
return this.errorUtilizationPenalty;
}
}
exports.WeightedRoundRobinLoadBalancingConfig = WeightedRoundRobinLoadBalancingConfig;
class WeightedRoundRobinPicker {
constructor(children, metricsHandler) {
this.metricsHandler = metricsHandler;
this.queue = new priority_queue_1.PriorityQueue((a, b) => a.deadline < b.deadline);
const positiveWeight = children.filter(picker => picker.weight > 0);
let averageWeight;
if (positiveWeight.length < 2) {
averageWeight = 1;
}
else {
let weightSum = 0;
for (const { weight } of positiveWeight) {
weightSum += weight;
}
averageWeight = weightSum / positiveWeight.length;
}
for (const child of children) {
const period = child.weight > 0 ? 1 / child.weight : averageWeight;
this.queue.push({
endpointName: child.endpointName,
picker: child.picker,
period: period,
deadline: Math.random() * period
});
}
}
pick(pickArgs) {
const entry = this.queue.pop();
this.queue.push(Object.assign(Object.assign({}, entry), { deadline: entry.deadline + entry.period }));
const childPick = entry.picker.pick(pickArgs);
if (childPick.pickResultType === picker_1.PickResultType.COMPLETE) {
if (this.metricsHandler) {
return Object.assign(Object.assign({}, childPick), { onCallEnded: (0, orca_1.createMetricsReader)(loadReport => this.metricsHandler(loadReport, entry.endpointName), childPick.onCallEnded) });
}
else {
const subchannelWrapper = childPick.subchannel;
return Object.assign(Object.assign({}, childPick), { subchannel: subchannelWrapper.getWrappedSubchannel() });
}
}
else {
return childPick;
}
}
}
class WeightedRoundRobinLoadBalancer {
constructor(channelControlHelper) {
this.channelControlHelper = channelControlHelper;
this.latestConfig = null;
this.children = new Map();
this.currentState = connectivity_state_1.ConnectivityState.IDLE;
this.updatesPaused = false;
this.lastError = null;
this.weightUpdateTimer = null;
}
countChildrenWithState(state) {
let count = 0;
for (const entry of this.children.values()) {
if (entry.child.getConnectivityState() === state) {
count += 1;
}
}
return count;
}
updateWeight(entry, loadReport) {
var _a, _b;
const qps = loadReport.rps_fractional;
let utilization = loadReport.application_utilization;
if (utilization > 0 && qps > 0) {
utilization += (loadReport.eps / qps) * ((_b = (_a = this.latestConfig) === null || _a === void 0 ? void 0 : _a.getErrorUtilizationPenalty()) !== null && _b !== void 0 ? _b : 0);
}
const newWeight = utilization === 0 ? 0 : qps / utilization;
if (newWeight === 0) {
return;
}
const now = new Date();
if (entry.nonEmptySince === null) {
entry.nonEmptySince = now;
}
entry.lastUpdated = now;
entry.weight = newWeight;
}
getWeight(entry) {
if (!this.latestConfig) {
return 0;
}
const now = new Date().getTime();
if (now - entry.lastUpdated.getTime() >= this.latestConfig.getWeightExpirationPeriodMs()) {
entry.nonEmptySince = null;
return 0;
}
const blackoutPeriod = this.latestConfig.getBlackoutPeriodMs();
if (blackoutPeriod > 0 && (entry.nonEmptySince === null || now - entry.nonEmptySince.getTime() < blackoutPeriod)) {
return 0;
}
return entry.weight;
}
calculateAndUpdateState() {
if (this.updatesPaused || !this.latestConfig) {
return;
}
if (this.countChildrenWithState(connectivity_state_1.ConnectivityState.READY) > 0) {
const weightedPickers = [];
for (const [endpoint, entry] of this.children) {
if (entry.child.getConnectivityState() !== connectivity_state_1.ConnectivityState.READY) {
continue;
}
weightedPickers.push({
endpointName: endpoint,
picker: entry.child.getPicker(),
weight: this.getWeight(entry)
});
}
trace('Created picker with weights: ' + weightedPickers.map(entry => entry.endpointName + ':' + entry.weight).join(','));
let metricsHandler;
if (!this.latestConfig.getEnableOobLoadReport()) {
metricsHandler = (loadReport, endpointName) => {
const childEntry = this.children.get(endpointName);
if (childEntry) {
this.updateWeight(childEntry, loadReport);
}
};
}
else {
metricsHandler = null;
}
this.updateState(connectivity_state_1.ConnectivityState.READY, new WeightedRoundRobinPicker(weightedPickers, metricsHandler), null);
}
else if (this.countChildrenWithState(connectivity_state_1.ConnectivityState.CONNECTING) > 0) {
this.updateState(connectivity_state_1.ConnectivityState.CONNECTING, new picker_1.QueuePicker(this), null);
}
else if (this.countChildrenWithState(connectivity_state_1.ConnectivityState.TRANSIENT_FAILURE) > 0) {
const errorMessage = `weighted_round_robin: No connection established. Last error: ${this.lastError}`;
this.updateState(connectivity_state_1.ConnectivityState.TRANSIENT_FAILURE, new picker_1.UnavailablePicker({
details: errorMessage,
}), errorMessage);
}
else {
this.updateState(connectivity_state_1.ConnectivityState.IDLE, new picker_1.QueuePicker(this), null);
}
for (const { child } of this.children.values()) {
if (child.getConnectivityState() === connectivity_state_1.ConnectivityState.IDLE) {
child.exitIdle();
}
}
}
updateState(newState, picker, errorMessage) {
trace(connectivity_state_1.ConnectivityState[this.currentState] +
' -> ' +
connectivity_state_1.ConnectivityState[newState]);
this.currentState = newState;
this.channelControlHelper.updateState(newState, picker, errorMessage);
}
updateAddressList(maybeEndpointList, lbConfig, options, resolutionNote) {
var _a, _b;
if (!(lbConfig instanceof WeightedRoundRobinLoadBalancingConfig)) {
return false;
}
if (!maybeEndpointList.ok) {
if (this.children.size === 0) {
this.updateState(connectivity_state_1.ConnectivityState.TRANSIENT_FAILURE, new picker_1.UnavailablePicker(maybeEndpointList.error), maybeEndpointList.error.details);
}
return true;
}
if (maybeEndpointList.value.length === 0) {
const errorMessage = `No addresses resolved. Resolution note: ${resolutionNote}`;
this.updateState(connectivity_state_1.ConnectivityState.TRANSIENT_FAILURE, new picker_1.UnavailablePicker({ details: errorMessage }), errorMessage);
return false;
}
trace('Connect to endpoint list ' + maybeEndpointList.value.map(subchannel_address_1.endpointToString));
const now = new Date();
const seenEndpointNames = new Set();
this.updatesPaused = true;
this.latestConfig = lbConfig;
for (const endpoint of maybeEndpointList.value) {
const name = (0, subchannel_address_1.endpointToString)(endpoint);
seenEndpointNames.add(name);
let entry = this.children.get(name);
if (!entry) {
entry = {
child: new load_balancer_pick_first_1.LeafLoadBalancer(endpoint, (0, load_balancer_1.createChildChannelControlHelper)(this.channelControlHelper, {
updateState: (connectivityState, picker, errorMessage) => {
if (this.currentState === connectivity_state_1.ConnectivityState.READY && connectivityState !== connectivity_state_1.ConnectivityState.READY) {
this.channelControlHelper.requestReresolution();
}
if (connectivityState === connectivity_state_1.ConnectivityState.READY) {
entry.nonEmptySince = null;
}
if (errorMessage) {
this.lastError = errorMessage;
}
this.calculateAndUpdateState();
},
createSubchannel: (subchannelAddress, subchannelArgs) => {
const subchannel = this.channelControlHelper.createSubchannel(subchannelAddress, subchannelArgs);
if (entry === null || entry === void 0 ? void 0 : entry.oobMetricsListener) {
return new orca_1.OrcaOobMetricsSubchannelWrapper(subchannel, entry.oobMetricsListener, this.latestConfig.getOobLoadReportingPeriodMs());
}
else {
return subchannel;
}
}
}), options, resolutionNote),
lastUpdated: now,
nonEmptySince: null,
weight: 0,
oobMetricsListener: null
};
this.children.set(name, entry);
}
if (lbConfig.getEnableOobLoadReport()) {
entry.oobMetricsListener = loadReport => {
this.updateWeight(entry, loadReport);
};
}
else {
entry.oobMetricsListener = null;
}
}
for (const [endpointName, entry] of this.children) {
if (seenEndpointNames.has(endpointName)) {
entry.child.startConnecting();
}
else {
entry.child.destroy();
this.children.delete(endpointName);
}
}
this.updatesPaused = false;
this.calculateAndUpdateState();
if (this.weightUpdateTimer) {
clearInterval(this.weightUpdateTimer);
}
this.weightUpdateTimer = (_b = (_a = setInterval(() => {
if (this.currentState === connectivity_state_1.ConnectivityState.READY) {
this.calculateAndUpdateState();
}
}, lbConfig.getWeightUpdatePeriodMs())).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
return true;
}
exitIdle() {
}
resetBackoff() {
}
destroy() {
for (const entry of this.children.values()) {
entry.child.destroy();
}
this.children.clear();
if (this.weightUpdateTimer) {
clearInterval(this.weightUpdateTimer);
}
}
getTypeName() {
return TYPE_NAME;
}
}
function setup() {
(0, load_balancer_1.registerLoadBalancerType)(TYPE_NAME, WeightedRoundRobinLoadBalancer, WeightedRoundRobinLoadBalancingConfig);
}