@ultipa-graph/ultipa-driver
Version:
NodeJS SDK for Ultipa GQL
247 lines • 25.9 kB
JavaScript
"use strict";
/**
* Connection management for GQLDB Node.js driver.
*/
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.ConnectionPool = void 0;
const grpc = __importStar(require("@grpc/grpc-js"));
const errors_1 = require("./errors");
/**
* Number of consecutive unhealthy ticks required before forcing a
* reconnect (which replaces the channel; in-flight RPCs are NOT
* cancelled because the old channel is left alive until GC).
*/
const UNHEALTHY_RECONNECT_THRESHOLD = 3;
/** Manages a pool of connections to GQLDB servers */
class ConnectionPool {
config;
connections = new Map();
closed = false;
healthCheckTimer;
constructor(config) {
this.config = config;
this.initConnections();
this.startHealthCheck();
}
initConnections() {
for (const host of this.config.hosts) {
try {
const conn = this.createConnection(host);
this.connections.set(host, conn);
}
catch (e) {
// Continue with other hosts
console.error(`Failed to connect to ${host}:`, e);
}
}
if (this.connections.size === 0) {
throw new errors_1.AllHostsFailedError();
}
}
createConnection(host) {
let credentials;
if (this.config.tlsOptions) {
credentials = grpc.credentials.createSsl();
}
else {
credentials = grpc.credentials.createInsecure();
}
const options = {
'grpc.max_receive_message_length': this.config.maxRecvSize ?? 64 * 1024 * 1024,
'grpc.max_send_message_length': this.config.maxRecvSize ?? 64 * 1024 * 1024,
'grpc.keepalive_time_ms': 30000,
'grpc.keepalive_timeout_ms': 10000,
'grpc.keepalive_permit_without_calls': 1,
};
// Create a generic client for the channel
const client = new grpc.Client(host, credentials, options);
return {
host,
client,
healthy: true,
lastPing: Date.now(),
consecutiveUnhealthy: 0,
};
}
/** Get a healthy connection from the pool */
getConnection() {
if (this.closed) {
throw new errors_1.ConnectionClosedError();
}
for (const conn of this.connections.values()) {
if (conn.healthy) {
return conn.client;
}
}
throw new errors_1.NoConnectionError();
}
/** Get a connection for a specific host */
getConnectionForHost(host) {
const conn = this.connections.get(host);
if (!conn || !conn.healthy) {
throw new errors_1.NoConnectionError();
}
return conn.client;
}
startHealthCheck() {
const interval = this.config.healthCheckInterval ?? 30000;
if (interval > 0) {
this.healthCheckTimer = setInterval(() => this.checkHealth(), interval);
}
}
/**
* Health-check tick. Connectivity-state semantics:
* - READY / IDLE → healthy; reset the unhealthy counter.
* - CONNECTING → transient; let the channel heal itself,
* don't count toward unhealthy.
* - SHUTDOWN → terminal; reconnect immediately.
* - TRANSIENT_FAILURE → count toward unhealthy; reconnect only
* after UNHEALTHY_RECONNECT_THRESHOLD
* consecutive ticks.
*
* Reconnect replaces the pool's channel reference; it does NOT close
* the old channel, so in-flight RPCs continue to completion on it.
*/
checkHealth() {
for (const [host, conn] of this.connections) {
const state = conn.client.getChannel().getConnectivityState(false);
if (state === grpc.connectivityState.READY ||
state === grpc.connectivityState.IDLE) {
conn.healthy = true;
conn.consecutiveUnhealthy = 0;
conn.lastPing = Date.now();
continue;
}
if (state === grpc.connectivityState.CONNECTING) {
// Transient — let the channel heal itself.
continue;
}
if (state === grpc.connectivityState.SHUTDOWN) {
conn.healthy = false;
conn.consecutiveUnhealthy = UNHEALTHY_RECONNECT_THRESHOLD;
this.reconnect(host);
continue;
}
// TRANSIENT_FAILURE or any other non-READY state.
conn.consecutiveUnhealthy++;
if (conn.consecutiveUnhealthy >= UNHEALTHY_RECONNECT_THRESHOLD) {
conn.healthy = false;
this.reconnect(host);
}
}
}
/**
* Replace the pool's channel for `host` with a fresh one.
*
* Critically, does NOT close the old channel. In-flight RPCs hold
* their own reference to it via the client they were issued on and
* continue to completion on that channel; the Node.js runtime's
* garbage collector releases the old channel only after every
* in-flight RPC has resolved.
*
* Earlier versions closed the old channel synchronously here, which
* cancelled every pending RPC with a "Channel closed!"-style error.
*/
/**
* Rebuild every host's gRPC client in the pool. Called by the client
* on transport-level errors (UNAVAILABLE / connection reset) so the
* next RPC gets a fresh channel. Like reconnect, this does NOT close
* old clients synchronously — in-flight RPCs hold them alive and gRPC
* closes them naturally once those calls complete.
*/
async forceReconnectAll() {
if (this.closed)
return;
const hosts = Array.from(this.connections.keys());
for (const host of hosts) {
await this.reconnect(host);
}
}
async reconnect(host) {
if (this.closed)
return;
try {
// Build the new connection up-front; only swap if it succeeds.
const newConn = this.createConnection(host);
// Overwrite the pool entry. The old Connection is now
// unreferenced by the pool; in-flight RPCs still hold its
// grpc.Client alive via per-call references. Once they
// complete the client becomes garbage and gRPC closes it
// naturally.
this.connections.set(host, newConn);
}
catch (e) {
console.error(`Failed to reconnect to ${host}:`, e);
}
}
/** Close all connections in the pool */
close() {
if (this.closed)
return;
this.closed = true;
if (this.healthCheckTimer) {
clearInterval(this.healthCheckTimer);
}
for (const conn of this.connections.values()) {
try {
conn.client.close();
}
catch (e) {
// Ignore
}
}
this.connections.clear();
}
/** Get the number of healthy hosts */
healthyHostCount() {
let count = 0;
for (const conn of this.connections.values()) {
if (conn.healthy)
count++;
}
return count;
}
/** Get the list of configured hosts */
hosts() {
return Array.from(this.connections.keys());
}
/** Check if the pool is closed */
isClosed() {
return this.closed;
}
}
exports.ConnectionPool = ConnectionPool;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connection.js","sourceRoot":"","sources":["../src/connection.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Connection management for GQLDB Node.js driver.\n */\n\nimport * as grpc from '@grpc/grpc-js';\nimport { GqldbConfig } from './config';\nimport { AllHostsFailedError, ConnectionClosedError, NoConnectionError } from './errors';\n\n/** Represents a single gRPC connection */\ninterface Connection {\n  host: string;\n  client: grpc.Client;\n  healthy: boolean;\n  lastPing: number;\n  /**\n   * Number of consecutive health-check ticks that observed a non-READY\n   * state. Reconnect is only triggered after this reaches\n   * UNHEALTHY_RECONNECT_THRESHOLD, so a single transient flicker\n   * during a busy in-flight RPC does not tear the channel down and\n   * cancel every pending request.\n   */\n  consecutiveUnhealthy: number;\n}\n\n/**\n * Number of consecutive unhealthy ticks required before forcing a\n * reconnect (which replaces the channel; in-flight RPCs are NOT\n * cancelled because the old channel is left alive until GC).\n */\nconst UNHEALTHY_RECONNECT_THRESHOLD = 3;\n\n/** Manages a pool of connections to GQLDB servers */\nexport class ConnectionPool {\n  private config: GqldbConfig;\n  private connections: Map<string, Connection> = new Map();\n  private closed = false;\n  private healthCheckTimer?: NodeJS.Timeout;\n\n  constructor(config: GqldbConfig) {\n    this.config = config;\n    this.initConnections();\n    this.startHealthCheck();\n  }\n\n  private initConnections(): void {\n    for (const host of this.config.hosts) {\n      try {\n        const conn = this.createConnection(host);\n        this.connections.set(host, conn);\n      } catch (e) {\n        // Continue with other hosts\n        console.error(`Failed to connect to ${host}:`, e);\n      }\n    }\n\n    if (this.connections.size === 0) {\n      throw new AllHostsFailedError();\n    }\n  }\n\n  private createConnection(host: string): Connection {\n    let credentials: grpc.ChannelCredentials;\n\n    if (this.config.tlsOptions) {\n      credentials = grpc.credentials.createSsl();\n    } else {\n      credentials = grpc.credentials.createInsecure();\n    }\n\n    const options: grpc.ChannelOptions = {\n      'grpc.max_receive_message_length': this.config.maxRecvSize ?? 64 * 1024 * 1024,\n      'grpc.max_send_message_length': this.config.maxRecvSize ?? 64 * 1024 * 1024,\n      'grpc.keepalive_time_ms': 30000,\n      'grpc.keepalive_timeout_ms': 10000,\n      'grpc.keepalive_permit_without_calls': 1,\n    };\n\n    // Create a generic client for the channel\n    const client = new grpc.Client(host, credentials, options);\n\n    return {\n      host,\n      client,\n      healthy: true,\n      lastPing: Date.now(),\n      consecutiveUnhealthy: 0,\n    };\n  }\n\n  /** Get a healthy connection from the pool */\n  getConnection(): grpc.Client {\n    if (this.closed) {\n      throw new ConnectionClosedError();\n    }\n\n    for (const conn of this.connections.values()) {\n      if (conn.healthy) {\n        return conn.client;\n      }\n    }\n\n    throw new NoConnectionError();\n  }\n\n  /** Get a connection for a specific host */\n  getConnectionForHost(host: string): grpc.Client {\n    const conn = this.connections.get(host);\n    if (!conn || !conn.healthy) {\n      throw new NoConnectionError();\n    }\n    return conn.client;\n  }\n\n  private startHealthCheck(): void {\n    const interval = this.config.healthCheckInterval ?? 30000;\n    if (interval > 0) {\n      this.healthCheckTimer = setInterval(() => this.checkHealth(), interval);\n    }\n  }\n\n  /**\n   * Health-check tick.  Connectivity-state semantics:\n   *  - READY / IDLE         → healthy; reset the unhealthy counter.\n   *  - CONNECTING           → transient; let the channel heal itself,\n   *                            don't count toward unhealthy.\n   *  - SHUTDOWN             → terminal; reconnect immediately.\n   *  - TRANSIENT_FAILURE    → count toward unhealthy; reconnect only\n   *                            after UNHEALTHY_RECONNECT_THRESHOLD\n   *                            consecutive ticks.\n   *\n   * Reconnect replaces the pool's channel reference; it does NOT close\n   * the old channel, so in-flight RPCs continue to completion on it.\n   */\n  private checkHealth(): void {\n    for (const [host, conn] of this.connections) {\n      const state = conn.client.getChannel().getConnectivityState(false);\n\n      if (state === grpc.connectivityState.READY ||\n          state === grpc.connectivityState.IDLE) {\n        conn.healthy = true;\n        conn.consecutiveUnhealthy = 0;\n        conn.lastPing = Date.now();\n        continue;\n      }\n\n      if (state === grpc.connectivityState.CONNECTING) {\n        // Transient — let the channel heal itself.\n        continue;\n      }\n\n      if (state === grpc.connectivityState.SHUTDOWN) {\n        conn.healthy = false;\n        conn.consecutiveUnhealthy = UNHEALTHY_RECONNECT_THRESHOLD;\n        this.reconnect(host);\n        continue;\n      }\n\n      // TRANSIENT_FAILURE or any other non-READY state.\n      conn.consecutiveUnhealthy++;\n      if (conn.consecutiveUnhealthy >= UNHEALTHY_RECONNECT_THRESHOLD) {\n        conn.healthy = false;\n        this.reconnect(host);\n      }\n    }\n  }\n\n  /**\n   * Replace the pool's channel for `host` with a fresh one.\n   *\n   * Critically, does NOT close the old channel.  In-flight RPCs hold\n   * their own reference to it via the client they were issued on and\n   * continue to completion on that channel; the Node.js runtime's\n   * garbage collector releases the old channel only after every\n   * in-flight RPC has resolved.\n   *\n   * Earlier versions closed the old channel synchronously here, which\n   * cancelled every pending RPC with a \"Channel closed!\"-style error.\n   */\n  /**\n   * Rebuild every host's gRPC client in the pool.  Called by the client\n   * on transport-level errors (UNAVAILABLE / connection reset) so the\n   * next RPC gets a fresh channel.  Like reconnect, this does NOT close\n   * old clients synchronously — in-flight RPCs hold them alive and gRPC\n   * closes them naturally once those calls complete.\n   */\n  async forceReconnectAll(): Promise<void> {\n    if (this.closed) return;\n    const hosts = Array.from(this.connections.keys());\n    for (const host of hosts) {\n      await this.reconnect(host);\n    }\n  }\n\n  private async reconnect(host: string): Promise<void> {\n    if (this.closed) return;\n\n    try {\n      // Build the new connection up-front; only swap if it succeeds.\n      const newConn = this.createConnection(host);\n      // Overwrite the pool entry.  The old Connection is now\n      // unreferenced by the pool; in-flight RPCs still hold its\n      // grpc.Client alive via per-call references.  Once they\n      // complete the client becomes garbage and gRPC closes it\n      // naturally.\n      this.connections.set(host, newConn);\n    } catch (e) {\n      console.error(`Failed to reconnect to ${host}:`, e);\n    }\n  }\n\n  /** Close all connections in the pool */\n  close(): void {\n    if (this.closed) return;\n\n    this.closed = true;\n\n    if (this.healthCheckTimer) {\n      clearInterval(this.healthCheckTimer);\n    }\n\n    for (const conn of this.connections.values()) {\n      try {\n        conn.client.close();\n      } catch (e) {\n        // Ignore\n      }\n    }\n\n    this.connections.clear();\n  }\n\n  /** Get the number of healthy hosts */\n  healthyHostCount(): number {\n    let count = 0;\n    for (const conn of this.connections.values()) {\n      if (conn.healthy) count++;\n    }\n    return count;\n  }\n\n  /** Get the list of configured hosts */\n  hosts(): string[] {\n    return Array.from(this.connections.keys());\n  }\n\n  /** Check if the pool is closed */\n  isClosed(): boolean {\n    return this.closed;\n  }\n}\n"]}