@elastic/elasticsearch 7.15.0

package/lib/pool/ConnectionPool.js

@@ -0,0 +1,246 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+'use strict'
+
+const BaseConnectionPool = require('./BaseConnectionPool')
+const assert = require('assert')
+const debug = require('debug')('elasticsearch')
+const Connection = require('../Connection')
+const noop = () => {}
+
+class ConnectionPool extends BaseConnectionPool {
+  constructor (opts) {
+    super(opts)
+
+    this.dead = []
+    // the resurrect timeout is 60s
+    this.resurrectTimeout = 1000 * 60
+    // number of consecutive failures after which
+    // the timeout doesn't increase
+    this.resurrectTimeoutCutoff = 5
+    this.pingTimeout = opts.pingTimeout
+    this._sniffEnabled = opts.sniffEnabled || false
+
+    const resurrectStrategy = opts.resurrectStrategy || 'ping'
+    this.resurrectStrategy = ConnectionPool.resurrectStrategies[resurrectStrategy]
+    assert(
+      this.resurrectStrategy != null,
+      `Invalid resurrection strategy: '${resurrectStrategy}'`
+    )
+  }
+
+  /**
+   * Marks a connection as 'alive'.
+   * If needed removes the connection from the dead list
+   * and then resets the `deadCount`.
+   *
+   * @param {object} connection
+   */
+  markAlive (connection) {
+    const { id } = connection
+    debug(`Marking as 'alive' connection '${id}'`)
+    const index = this.dead.indexOf(id)
+    if (index > -1) this.dead.splice(index, 1)
+    connection.status = Connection.statuses.ALIVE
+    connection.deadCount = 0
+    connection.resurrectTimeout = 0
+    return this
+  }
+
+  /**
+   * Marks a connection as 'dead'.
+   * If needed adds the connection to the dead list
+   * and then increments the `deadCount`.
+   *
+   * @param {object} connection
+   */
+  markDead (connection) {
+    const { id } = connection
+    debug(`Marking as 'dead' connection '${id}'`)
+    if (this.dead.indexOf(id) === -1) {
+      // It might happen that `markDead` is called jsut after
+      // a pool update, and in such case we will add to the dead
+      // list a node that no longer exist. The following check verify
+      // that the connection is still part of the pool before
+      // marking it as dead.
+      for (let i = 0; i < this.size; i++) {
+        if (this.connections[i].id === id) {
+          this.dead.push(id)
+          break
+        }
+      }
+    }
+    connection.status = Connection.statuses.DEAD
+    connection.deadCount++
+    // resurrectTimeout formula:
+    // `resurrectTimeout * 2 ** min(deadCount - 1, resurrectTimeoutCutoff)`
+    connection.resurrectTimeout = Date.now() + this.resurrectTimeout * Math.pow(
+      2, Math.min(connection.deadCount - 1, this.resurrectTimeoutCutoff)
+    )
+
+    // sort the dead list in ascending order
+    // based on the resurrectTimeout
+    this.dead.sort((a, b) => {
+      const conn1 = this.connections.find(c => c.id === a)
+      const conn2 = this.connections.find(c => c.id === b)
+      return conn1.resurrectTimeout - conn2.resurrectTimeout
+    })
+
+    return this
+  }
+
+  /**
+   * If enabled, tries to resurrect a connection with the given
+   * resurrect strategy ('ping', 'optimistic', 'none').
+   *
+   * @param {object} { now, requestId }
+   * @param {function} callback (isAlive, connection)
+   */
+  resurrect (opts, callback = noop) {
+    if (this.resurrectStrategy === 0 || this.dead.length === 0) {
+      debug('Nothing to resurrect')
+      callback(null, null)
+      return
+    }
+
+    // the dead list is sorted in ascending order based on the timeout
+    // so the first element will always be the one with the smaller timeout
+    const connection = this.connections.find(c => c.id === this.dead[0])
+    if ((opts.now || Date.now()) < connection.resurrectTimeout) {
+      debug('Nothing to resurrect')
+      callback(null, null)
+      return
+    }
+
+    const { id } = connection
+
+    // ping strategy
+    if (this.resurrectStrategy === 1) {
+      connection.request({
+        method: 'HEAD',
+        path: '/',
+        timeout: this.pingTimeout
+      }, (err, response) => {
+        let isAlive = true
+        const statusCode = response !== null ? response.statusCode : 0
+        if (err != null ||
+           (statusCode === 502 || statusCode === 503 || statusCode === 504)) {
+          debug(`Resurrect: connection '${id}' is still dead`)
+          this.markDead(connection)
+          isAlive = false
+        } else {
+          debug(`Resurrect: connection '${id}' is now alive`)
+          this.markAlive(connection)
+        }
+        this.emit('resurrect', null, {
+          strategy: 'ping',
+          name: opts.name,
+          request: { id: opts.requestId },
+          isAlive,
+          connection
+        })
+        callback(isAlive, connection)
+      })
+    // optimistic strategy
+    } else {
+      debug(`Resurrect: optimistic resurrection for connection '${id}'`)
+      this.dead.splice(this.dead.indexOf(id), 1)
+      connection.status = Connection.statuses.ALIVE
+      this.emit('resurrect', null, {
+        strategy: 'optimistic',
+        name: opts.name,
+        request: { id: opts.requestId },
+        isAlive: true,
+        connection
+      })
+      callback(true, connection) // eslint-disable-line
+    }
+  }
+
+  /**
+   * Returns an alive connection if present,
+   * otherwise returns a dead connection.
+   * By default it filters the `master` only nodes.
+   * It uses the selector to choose which
+   * connection return.
+   *
+   * @param {object} options (filter and selector)
+   * @returns {object|null} connection
+   */
+  getConnection (opts = {}) {
+    const filter = opts.filter || (() => true)
+    const selector = opts.selector || (c => c[0])
+
+    this.resurrect({
+      now: opts.now,
+      requestId: opts.requestId,
+      name: opts.name
+    })
+
+    const noAliveConnections = this.size === this.dead.length
+
+    // TODO: can we cache this?
+    const connections = []
+    for (let i = 0; i < this.size; i++) {
+      const connection = this.connections[i]
+      if (noAliveConnections || connection.status === Connection.statuses.ALIVE) {
+        if (filter(connection) === true) {
+          connections.push(connection)
+        }
+      }
+    }
+
+    if (connections.length === 0) return null
+
+    return selector(connections)
+  }
+
+  /**
+   * Empties the connection pool.
+   *
+   * @returns {ConnectionPool}
+   */
+  empty (callback) {
+    super.empty(() => {
+      this.dead = []
+      callback()
+    })
+  }
+
+  /**
+   * Update the ConnectionPool with new connections.
+   *
+   * @param {array} array of connections
+   * @returns {ConnectionPool}
+   */
+  update (connections) {
+    super.update(connections)
+    this.dead = []
+    return this
+  }
+}
+
+ConnectionPool.resurrectStrategies = {
+  none: 0,
+  ping: 1,
+  optimistic: 2
+}
+
+module.exports = ConnectionPool

package/lib/pool/index.d.ts

@@ -0,0 +1,220 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/// <reference types="node" />
+
+import { URL } from 'url'
+import { SecureContextOptions } from 'tls';
+import Connection, { AgentOptions } from '../Connection';
+import { nodeFilterFn, nodeSelectorFn } from '../Transport';
+
+interface BaseConnectionPoolOptions {
+  ssl?: SecureContextOptions;
+  agent?: AgentOptions;
+  proxy?: string | URL;
+  auth?: BasicAuth | ApiKeyAuth;
+  emit: (event: string | symbol, ...args: any[]) => boolean;
+  Connection: typeof Connection;
+  caFingerprint?: string;
+}
+
+interface ConnectionPoolOptions extends BaseConnectionPoolOptions {
+  pingTimeout?: number;
+  resurrectStrategy?: 'ping' | 'optimistic' | 'none';
+  sniffEnabled?: boolean;
+}
+
+interface getConnectionOptions {
+  filter?: nodeFilterFn;
+  selector?: nodeSelectorFn;
+  requestId?: string | number;
+  name?: string;
+  now?: number;
+}
+
+interface ApiKeyAuth {
+  apiKey:
+    | string
+    | {
+        id: string;
+        api_key: string;
+      }
+}
+
+interface BasicAuth {
+  username: string;
+  password: string;
+}
+
+interface BearerAuth {
+  bearer: string
+}
+
+interface resurrectOptions {
+  now?: number;
+  requestId: string;
+  name: string;
+}
+
+interface ResurrectEvent {
+  strategy: string;
+  isAlive: boolean;
+  connection: Connection;
+  name: string;
+  request: {
+    id: any;
+  };
+}
+
+
+declare class BaseConnectionPool {
+  connections: Connection[];
+  size: number;
+  emit: (event: string | symbol, ...args: any[]) => boolean;
+  _ssl: SecureContextOptions | null;
+  _agent: AgentOptions | null;
+  _proxy: string | URL;
+  auth: BasicAuth | ApiKeyAuth;
+  Connection: typeof Connection;
+  constructor(opts?: BaseConnectionPoolOptions);
+  /**
+   * Marks a connection as 'alive'.
+   * If needed removes the connection from the dead list
+   * and then resets the `deadCount`.
+   *
+   * @param {object} connection
+   */
+  markAlive(connection: Connection): this;
+  /**
+   * Marks a connection as 'dead'.
+   * If needed adds the connection to the dead list
+   * and then increments the `deadCount`.
+   *
+   * @param {object} connection
+   */
+  markDead(connection: Connection): this;
+  /**
+   * Returns an alive connection if present,
+   * otherwise returns a dead connection.
+   * By default it filters the `master` only nodes.
+   * It uses the selector to choose which
+   * connection return.
+   *
+   * @param {object} options (filter and selector)
+   * @returns {object|null} connection
+   */
+  getConnection(opts?: getConnectionOptions): Connection | null;
+  /**
+   * Adds a new connection to the pool.
+   *
+   * @param {object|string} host
+   * @returns {ConnectionPool}
+   */
+  addConnection(opts: any): Connection;
+  /**
+   * Removes a new connection to the pool.
+   *
+   * @param {object} connection
+   * @returns {ConnectionPool}
+   */
+  removeConnection(connection: Connection): this;
+  /**
+   * Empties the connection pool.
+   *
+   * @returns {ConnectionPool}
+   */
+  empty(): this;
+  /**
+   * Update the ConnectionPool with new connections.
+   *
+   * @param {array} array of connections
+   * @returns {ConnectionPool}
+   */
+  update(connections: any[]): this;
+  /**
+   * Transforms the nodes objects to a host object.
+   *
+   * @param {object} nodes
+   * @returns {array} hosts
+   */
+  nodesToHost(nodes: any, protocol: string): any[];
+  /**
+   * Transforms an url string to a host object
+   *
+   * @param {string} url
+   * @returns {object} host
+   */
+  urlToHost(url: string): { url: URL };
+}
+
+declare class ConnectionPool extends BaseConnectionPool {
+  static resurrectStrategies: {
+    none: number;
+    ping: number;
+    optimistic: number;
+  };
+  dead: string[];
+  _sniffEnabled: boolean;
+  resurrectTimeout: number;
+  resurrectTimeoutCutoff: number;
+  pingTimeout: number;
+  resurrectStrategy: number;
+  constructor(opts?: ConnectionPoolOptions);
+
+  /**
+   * If enabled, tries to resurrect a connection with the given
+   * resurrect strategy ('ping', 'optimistic', 'none').
+   *
+   * @param {object} { now, requestId, name }
+   * @param {function} callback (isAlive, connection)
+   */
+  resurrect(opts: resurrectOptions, callback?: (isAlive: boolean | null, connection: Connection | null) => void): void;
+}
+
+declare class CloudConnectionPool extends BaseConnectionPool {
+  cloudConnection: Connection | null
+  constructor(opts?: BaseConnectionPoolOptions);
+  getConnection(): Connection | null;
+}
+
+declare function defaultNodeFilter(node: Connection): boolean;
+declare function roundRobinSelector(): (connections: Connection[]) => Connection;
+declare function randomSelector(connections: Connection[]): Connection;
+
+declare const internals: {
+  defaultNodeFilter: typeof defaultNodeFilter;
+  roundRobinSelector: typeof roundRobinSelector;
+  randomSelector: typeof randomSelector;
+};
+
+export {
+  // Interfaces
+  ConnectionPoolOptions,
+  getConnectionOptions,
+  ApiKeyAuth,
+  BasicAuth,
+  BearerAuth,
+  internals,
+  resurrectOptions,
+  ResurrectEvent,
+  // Classes
+  BaseConnectionPool,
+  ConnectionPool,
+  CloudConnectionPool
+};

package/lib/pool/index.js

@@ -0,0 +1,30 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+'use strict'
+
+const BaseConnectionPool = require('./BaseConnectionPool')
+const ConnectionPool = require('./ConnectionPool')
+const CloudConnectionPool = require('./CloudConnectionPool')
+
+module.exports = {
+  BaseConnectionPool,
+  ConnectionPool,
+  CloudConnectionPool
+}

package/package.json

@@ -0,0 +1,106 @@
+{
+  "name": "@elastic/elasticsearch",
+  "description": "The official Elasticsearch client for Node.js",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.mjs"
+    },
+    "./": "./"
+  },
+  "homepage": "http://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/index.html",
+  "version": "7.15.0",
+  "versionCanary": "7.15.0-canary.3",
+  "keywords": [
+    "elasticsearch",
+    "elastic",
+    "kibana",
+    "mapping",
+    "REST",
+    "search",
+    "client",
+    "index"
+  ],
+  "scripts": {
+    "test": "npm run lint && tap test/{unit,acceptance}/{*,**/*}.test.js && npm run test:types",
+    "test:unit": "tap test/unit/{*,**/*}.test.js",
+    "test:acceptance": "tap test/acceptance/*.test.js",
+    "test:integration": "node test/integration/index.js",
+    "test:integration:helpers": "tap test/integration/helpers/*.test.js",
+    "test:types": "tsd",
+    "test:coverage-100": "tap test/{unit,acceptance}/{*,**/*}.test.js --coverage --100 --nyc-arg=\"--exclude=api\"",
+    "test:coverage-report": "tap test/{unit,acceptance}/{*,**/*}.test.js --coverage --nyc-arg=\"--exclude=api\" && nyc report --reporter=text-lcov > coverage.lcov",
+    "test:coverage-ui": "tap test/{unit,acceptance}/{*,**/*}.test.js --coverage --coverage-report=html --nyc-arg=\"--exclude=api\"",
+    "lint": "standard",
+    "lint:fix": "standard --fix",
+    "license-checker": "license-checker --production --onlyAllow='MIT;Apache-2.0;Apache1.1;ISC;BSD-3-Clause;BSD-2-Clause'",
+    "build-esm": "npx gen-esm-wrapper . index.mjs && standard --fix index.mjs"
+  },
+  "author": {
+    "name": "Tomas Della Vedova",
+    "company": "Elastic BV"
+  },
+  "original-author": {
+    "name": "Spencer Alger",
+    "company": "Elasticsearch BV"
+  },
+  "devDependencies": {
+    "@sinonjs/fake-timers": "github:sinonjs/fake-timers#0bfffc1",
+    "@types/node": "^15.3.1",
+    "convert-hrtime": "^5.0.0",
+    "cross-zip": "^4.0.0",
+    "dedent": "^0.7.0",
+    "deepmerge": "^4.2.2",
+    "dezalgo": "^1.0.3",
+    "fast-deep-equal": "^3.1.3",
+    "into-stream": "^6.0.0",
+    "js-yaml": "^4.1.0",
+    "license-checker": "^25.0.1",
+    "minimist": "^1.2.5",
+    "node-fetch": "^2.6.1",
+    "ora": "^5.4.0",
+    "pretty-hrtime": "^1.0.3",
+    "proxy": "^1.0.2",
+    "rimraf": "^3.0.2",
+    "semver": "^7.3.5",
+    "simple-git": "^2.39.0",
+    "simple-statistics": "^7.7.0",
+    "split2": "^3.2.2",
+    "standard": "^16.0.3",
+    "stoppable": "^1.1.0",
+    "tap": "^15.0.9",
+    "tsd": "^0.15.1",
+    "workq": "^3.0.0",
+    "xmlbuilder2": "^2.4.1"
+  },
+  "dependencies": {
+    "debug": "^4.3.1",
+    "hpagent": "^0.1.1",
+    "ms": "^2.1.3",
+    "secure-json-parse": "^2.4.0"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/elastic/elasticsearch-js.git"
+  },
+  "bugs": {
+    "url": "https://github.com/elastic/elasticsearch-js/issues"
+  },
+  "engines": {
+    "node": ">=12"
+  },
+  "tsd": {
+    "directory": "test/types"
+  },
+  "tap": {
+    "ts": false,
+    "jsx": false,
+    "flow": false,
+    "coverage": false,
+    "jobs-auto": true,
+    "check-coverage": false
+  }
+}