@ragestudio/scylla-odm 0.22.2 → 0.22.4

package/driver/metadata/client-state.js

@@ -0,0 +1,119 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF 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.
+ */
+import util from "util"
+import errors from "../errors.js"
+
+/**
+ * Represents the state of a {@link Client}.
+ * <p>
+ * Exposes information on the connections maintained by a Client at a specific time.
+ * </p>
+ * @alias module:metadata~ClientState
+ * @constructor
+ */
+class ClientState {
+	/**
+	 * Creates a new instance of <code>ClientState</code>.
+	 * @param {Array<Host>} hosts
+	 * @param {Object.<String, Number>} openConnections
+	 * @param {Object.<String, Number>} inFlightQueries
+	 */
+	constructor(hosts, openConnections, inFlightQueries) {
+		this._hosts = hosts
+		this._openConnections = openConnections
+		this._inFlightQueries = inFlightQueries
+	}
+
+	/**
+	 * Get an array of hosts to which the client is connected to.
+	 * @return {Array<Host>}
+	 */
+	getConnectedHosts() {
+		return this._hosts
+	}
+
+	/**
+	 * Gets the amount of open connections to a given host.
+	 * @param {Host} host
+	 * @return {Number}
+	 */
+	getOpenConnections(host) {
+		if (!host) {
+			throw new errors.ArgumentError("Host is not defined")
+		}
+
+		return this._openConnections[host.address] || 0
+	}
+
+	/**
+	 * Gets the amount of queries that are currently being executed through a given host.
+	 * <p>
+	 * This corresponds to the number of queries that have been sent by the Client to server Host on one of its connections
+	 * but haven't yet obtained a response.
+	 * </p>
+	 * @param {Host} host
+	 * @return {Number}
+	 */
+	getInFlightQueries(host) {
+		if (!host) {
+			throw new errors.ArgumentError("Host is not defined")
+		}
+
+		return this._inFlightQueries[host.address] || 0
+	}
+
+	/**
+	 * Returns the string representation of the instance.
+	 */
+	toString() {
+		return util.format(
+			'{"hosts": %j, "openConnections": %j, "inFlightQueries": %j}',
+			this._hosts.map(function (h) {
+				return h.address
+			}),
+			this._openConnections,
+			this._inFlightQueries,
+		)
+	}
+
+	/**
+	 * Creates a new instance from the provided client.
+	 * @param {Client} client
+	 * @internal
+	 * @ignore
+	 */
+	static from(client) {
+		const openConnections = {}
+		const inFlightQueries = {}
+		const hostArray = []
+
+		client.hosts.forEach((host) => {
+			if (host.pool.connections.length === 0) {
+				return
+			}
+
+			hostArray.push(host)
+			openConnections[host.address] = host.pool.connections.length
+			inFlightQueries[host.address] = host.getInFlight()
+		})
+
+		return new ClientState(hostArray, openConnections, inFlightQueries)
+	}
+}
+
+export default ClientState

package/driver/metadata/data-collection.js

@@ -0,0 +1,182 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF 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.
+ */
+import util from "util"
+import events from "events"
+/**
+ * Creates a new instance of DataCollection
+ * @param {String} name Name of the data object.
+ * @classdesc Describes a table or a view
+ * @alias module:metadata~DataCollection
+ * @constructor
+ * @abstract
+ */
+function DataCollection(name) {
+	events.EventEmitter.call(this)
+	this.setMaxListeners(0)
+	//private
+	Object.defineProperty(this, "loading", {
+		value: false,
+		enumerable: false,
+		writable: true,
+	})
+	Object.defineProperty(this, "loaded", {
+		value: false,
+		enumerable: false,
+		writable: true,
+	})
+	/**
+	 * Name of the object
+	 * @type {String}
+	 */
+	this.name = name
+	/**
+	 * False-positive probability for SSTable Bloom filters.
+	 * @type {number}
+	 */
+	this.bloomFilterFalsePositiveChance = 0
+	/**
+	 * Level of caching: all, keys_only, rows_only, none
+	 * @type {String}
+	 */
+	this.caching = null
+	/**
+	 * A human readable comment describing the table.
+	 * @type {String}
+	 */
+	this.comment = null
+	/**
+	 * Specifies the time to wait before garbage collecting tombstones (deletion markers)
+	 * @type {number}
+	 */
+	this.gcGraceSeconds = 0
+	/**
+	 * Compaction strategy class used for the table.
+	 * @type {String}
+	 */
+	this.compactionClass = null
+	/**
+	 * Associative-array containing the compaction options keys and values.
+	 * @type {Object}
+	 */
+	this.compactionOptions = null
+	/**
+	 * Associative-array containing the compression options.
+	 * @type {Object}
+	 */
+	this.compression = null
+	/**
+	 * Specifies the probability of read repairs being invoked over all replicas in the current data center.
+	 * @type {number}
+	 */
+	this.localReadRepairChance = 0
+	/**
+	 * Specifies the probability with which read repairs should be invoked on non-quorum reads. The value must be
+	 * between 0 and 1.
+	 * @type {number}
+	 */
+	this.readRepairChance = 0
+	/**
+	 * An associative Array containing extra metadata for the table.
+	 * <p>
+	 * For Apache Cassandra versions prior to 3.0.0, this method always returns <code>null</code>.
+	 * </p>
+	 * @type {Object}
+	 */
+	this.extensions = null
+	/**
+	 * When compression is enabled, this option defines the probability
+	 * with which checksums for compressed blocks are checked during reads.
+	 * The default value for this options is 1.0 (always check).
+	 * <p>
+	 *   For Apache Cassandra versions prior to 3.0.0, this method always returns <code>null</code>.
+	 * </p>
+	 * @type {Number|null}
+	 */
+	this.crcCheckChance = null
+	/**
+	 * Whether the populate I/O cache on flush is set on this table.
+	 * @type {Boolean}
+	 */
+	this.populateCacheOnFlush = false
+	/**
+	 * Returns the default TTL for this table.
+	 * @type {Number}
+	 */
+	this.defaultTtl = 0
+	/**
+	 * * Returns the speculative retry option for this table.
+	 * @type {String}
+	 */
+	this.speculativeRetry = "NONE"
+	/**
+	 * Returns the minimum index interval option for this table.
+	 * <p>
+	 *   Note: this option is available in Apache Cassandra 2.1 and above, and will return <code>null</code> for
+	 *   earlier versions.
+	 * </p>
+	 * @type {Number|null}
+	 */
+	this.minIndexInterval = 128
+	/**
+	 * Returns the maximum index interval option for this table.
+	 * <p>
+	 * Note: this option is available in Apache Cassandra 2.1 and above, and will return <code>null</code> for
+	 * earlier versions.
+	 * </p>
+	 * @type {Number|null}
+	 */
+	this.maxIndexInterval = 2048
+	/**
+	 * Array describing the table columns.
+	 * @type {Array}
+	 */
+	this.columns = null
+	/**
+	 * An associative Array of columns by name.
+	 * @type {Object}
+	 */
+	this.columnsByName = null
+	/**
+	 * Array describing the columns that are part of the partition key.
+	 * @type {Array}
+	 */
+	this.partitionKeys = []
+	/**
+	 * Array describing the columns that form the clustering key.
+	 * @type {Array}
+	 */
+	this.clusteringKeys = []
+	/**
+	 * Array describing the clustering order of the columns in the same order as the clusteringKeys.
+	 * @type {Array}
+	 */
+	this.clusteringOrder = []
+	/**
+	 * An associative Array containing nodesync options for this table.
+	 * <p>
+	 * For DSE versions prior to 6.0.0, this method always returns {@code null}.  If nodesync
+	 * was not explicitly configured for this table this method will also return {@code null}.
+	 * </p>
+	 * @type {Object}
+	 */
+	this.nodesync = null
+}
+
+util.inherits(DataCollection, events.EventEmitter)
+
+export default DataCollection

package/driver/metadata/event-debouncer.js

@@ -0,0 +1,174 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF 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.
+ */
+import util from "util"
+import utils from "../utils.js"
+import promiseUtils from "../promise-utils.js"
+
+const _queueOverflowThreshold = 1000
+
+/**
+ * Debounce protocol events by acting on those events with a sliding delay.
+ * @ignore
+ * @constructor
+ */
+class EventDebouncer {
+	/**
+	 * Creates a new instance of the event debouncer.
+	 * @param {Number} delay
+	 * @param {Function} logger
+	 */
+	constructor(delay, logger) {
+		this._delay = delay
+		this._logger = logger
+		this._queue = null
+		this._timeout = null
+	}
+
+	/**
+	 * Adds a new event to the queue and moves the delay.
+	 * @param {{ handler: Function, all: boolean|undefined, keyspace: String|undefined,
+	 * cqlObject: String|null|undefined }} event
+	 * @param {Boolean} processNow
+	 * @returns {Promise}
+	 */
+	eventReceived(event, processNow) {
+		return new Promise((resolve, reject) => {
+			event.callback = promiseUtils.getCallback(resolve, reject)
+			this._queue = this._queue || { callbacks: [], keyspaces: {} }
+			const delay = !processNow ? this._delay : 0
+			if (event.all) {
+				// when an event marked with all is received, it supersedes all the rest of events
+				// a full update (hosts + keyspaces + tokens) is going to be made
+				this._queue.mainEvent = event
+			}
+			if (this._queue.callbacks.length === _queueOverflowThreshold) {
+				// warn once
+				this._logger(
+					"warn",
+					util.format(
+						"Event debouncer queue exceeded %d events",
+						_queueOverflowThreshold,
+					),
+				)
+			}
+			this._queue.callbacks.push(event.callback)
+			if (this._queue.mainEvent) {
+				// a full refresh is scheduled and the callback was added, nothing else to do.
+				return this._slideDelay(delay)
+			}
+			// Insert at keyspace level
+			let keyspaceEvents = this._queue.keyspaces[event.keyspace]
+			if (!keyspaceEvents) {
+				keyspaceEvents = this._queue.keyspaces[event.keyspace] = {
+					events: [],
+				}
+			}
+			if (event.cqlObject === undefined) {
+				// a full refresh of the keyspace, supersedes all child keyspace events
+				keyspaceEvents.mainEvent = event
+			}
+			keyspaceEvents.events.push(event)
+			this._slideDelay(delay)
+		})
+	}
+
+	/**
+	 * @param {Number} delay
+	 * @private
+	 * */
+	_slideDelay(delay) {
+		const self = this
+		function process() {
+			const q = self._queue
+			self._queue = null
+			self._timeout = null
+			processQueue(q)
+		}
+		if (delay === 0) {
+			// no delay, process immediately
+			if (this._timeout) {
+				clearTimeout(this._timeout)
+			}
+			return process()
+		}
+		const previousTimeout = this._timeout
+		// Add the new timeout before removing the previous one performs better
+		this._timeout = setTimeout(process, delay)
+		if (previousTimeout) {
+			clearTimeout(previousTimeout)
+		}
+	}
+
+	/**
+	 * Clears the timeout and invokes all pending callback.
+	 */
+	shutdown() {
+		if (!this._queue) {
+			return
+		}
+		this._queue.callbacks.forEach(function (cb) {
+			cb()
+		})
+		this._queue = null
+		clearTimeout(this._timeout)
+		this._timeout = null
+	}
+}
+
+/**
+ * @param {{callbacks: Array, keyspaces: Object, mainEvent: Object}} q
+ * @private
+ */
+function processQueue(q) {
+	if (q.mainEvent) {
+		// refresh all by invoking 1 handler and invoke all pending callbacks
+		return promiseUtils.toCallback(q.mainEvent.handler(), (err) => {
+			for (let i = 0; i < q.callbacks.length; i++) {
+				q.callbacks[i](err)
+			}
+		})
+	}
+
+	utils.each(Object.keys(q.keyspaces), function eachKeyspace(name, next) {
+		const keyspaceEvents = q.keyspaces[name]
+		if (keyspaceEvents.mainEvent) {
+			// refresh a keyspace
+			return promiseUtils.toCallback(
+				keyspaceEvents.mainEvent.handler(),
+				function mainEventCallback(err) {
+					for (let i = 0; i < keyspaceEvents.events.length; i++) {
+						keyspaceEvents.events[i].callback(err)
+					}
+
+					next()
+				},
+			)
+		}
+
+		// deal with individual handlers and callbacks
+		keyspaceEvents.events.forEach((event) => {
+			// sync handlers
+			event.handler()
+			event.callback()
+		})
+
+		next()
+	})
+}
+
+export default EventDebouncer