mirror of
https://github.com/xfarrow/blink
synced 2025-06-27 09:03:02 +02:00
Change endpoint from persons to people
This commit is contained in:
xfarrow
516
backend/apis/nodejs/node_modules/tarn/dist/Pool.js
generated
vendored
Normal file
516
backend/apis/nodejs/node_modules/tarn/dist/Pool.js
generated
vendored
Normal file
@ -0,0 +1,516 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const PendingOperation_1 = require("./PendingOperation");
|
||||
const Resource_1 = require("./Resource");
|
||||
const utils_1 = require("./utils");
|
||||
const events_1 = require("events");
|
||||
const timers_1 = require("timers");
|
||||
class Pool {
|
||||
constructor(opt) {
|
||||
this.destroyed = false;
|
||||
this.emitter = new events_1.EventEmitter();
|
||||
opt = opt || {};
|
||||
if (!opt.create) {
|
||||
throw new Error('Tarn: opt.create function most be provided');
|
||||
}
|
||||
if (!opt.destroy) {
|
||||
throw new Error('Tarn: opt.destroy function most be provided');
|
||||
}
|
||||
if (typeof opt.min !== 'number' || opt.min < 0 || opt.min !== Math.round(opt.min)) {
|
||||
throw new Error('Tarn: opt.min must be an integer >= 0');
|
||||
}
|
||||
if (typeof opt.max !== 'number' || opt.max <= 0 || opt.max !== Math.round(opt.max)) {
|
||||
throw new Error('Tarn: opt.max must be an integer > 0');
|
||||
}
|
||||
if (opt.min > opt.max) {
|
||||
throw new Error('Tarn: opt.max is smaller than opt.min');
|
||||
}
|
||||
if (!utils_1.checkOptionalTime(opt.acquireTimeoutMillis)) {
|
||||
throw new Error('Tarn: invalid opt.acquireTimeoutMillis ' + JSON.stringify(opt.acquireTimeoutMillis));
|
||||
}
|
||||
if (!utils_1.checkOptionalTime(opt.createTimeoutMillis)) {
|
||||
throw new Error('Tarn: invalid opt.createTimeoutMillis ' + JSON.stringify(opt.createTimeoutMillis));
|
||||
}
|
||||
if (!utils_1.checkOptionalTime(opt.destroyTimeoutMillis)) {
|
||||
throw new Error('Tarn: invalid opt.destroyTimeoutMillis ' + JSON.stringify(opt.destroyTimeoutMillis));
|
||||
}
|
||||
if (!utils_1.checkOptionalTime(opt.idleTimeoutMillis)) {
|
||||
throw new Error('Tarn: invalid opt.idleTimeoutMillis ' + JSON.stringify(opt.idleTimeoutMillis));
|
||||
}
|
||||
if (!utils_1.checkOptionalTime(opt.reapIntervalMillis)) {
|
||||
throw new Error('Tarn: invalid opt.reapIntervalMillis ' + JSON.stringify(opt.reapIntervalMillis));
|
||||
}
|
||||
if (!utils_1.checkOptionalTime(opt.createRetryIntervalMillis)) {
|
||||
throw new Error('Tarn: invalid opt.createRetryIntervalMillis ' +
|
||||
JSON.stringify(opt.createRetryIntervalMillis));
|
||||
}
|
||||
const allowedKeys = {
|
||||
create: true,
|
||||
validate: true,
|
||||
destroy: true,
|
||||
log: true,
|
||||
min: true,
|
||||
max: true,
|
||||
acquireTimeoutMillis: true,
|
||||
createTimeoutMillis: true,
|
||||
destroyTimeoutMillis: true,
|
||||
idleTimeoutMillis: true,
|
||||
reapIntervalMillis: true,
|
||||
createRetryIntervalMillis: true,
|
||||
propagateCreateError: true
|
||||
};
|
||||
for (const key of Object.keys(opt)) {
|
||||
if (!allowedKeys[key]) {
|
||||
throw new Error(`Tarn: unsupported option opt.${key}`);
|
||||
}
|
||||
}
|
||||
this.creator = opt.create;
|
||||
this.destroyer = opt.destroy;
|
||||
this.validate = typeof opt.validate === 'function' ? opt.validate : () => true;
|
||||
this.log = opt.log || (() => { });
|
||||
this.acquireTimeoutMillis = opt.acquireTimeoutMillis || 30000;
|
||||
this.createTimeoutMillis = opt.createTimeoutMillis || 30000;
|
||||
this.destroyTimeoutMillis = opt.destroyTimeoutMillis || 5000;
|
||||
this.idleTimeoutMillis = opt.idleTimeoutMillis || 30000;
|
||||
this.reapIntervalMillis = opt.reapIntervalMillis || 1000;
|
||||
this.createRetryIntervalMillis = opt.createRetryIntervalMillis || 200;
|
||||
this.propagateCreateError = !!opt.propagateCreateError;
|
||||
this.min = opt.min;
|
||||
this.max = opt.max;
|
||||
// All the resources, which are either already acquired or which are
|
||||
// considered for being passed to acquire in async validation phase.
|
||||
this.used = [];
|
||||
// All the resources, which are either just created and free or returned
|
||||
// back to pool after using.
|
||||
this.free = [];
|
||||
this.pendingCreates = [];
|
||||
this.pendingAcquires = [];
|
||||
this.pendingDestroys = [];
|
||||
// When acquire is pending, but also still in validation phase
|
||||
this.pendingValidations = [];
|
||||
this.destroyed = false;
|
||||
this.interval = null;
|
||||
this.eventId = 1;
|
||||
}
|
||||
numUsed() {
|
||||
return this.used.length;
|
||||
}
|
||||
numFree() {
|
||||
return this.free.length;
|
||||
}
|
||||
numPendingAcquires() {
|
||||
return this.pendingAcquires.length;
|
||||
}
|
||||
numPendingValidations() {
|
||||
return this.pendingValidations.length;
|
||||
}
|
||||
numPendingCreates() {
|
||||
return this.pendingCreates.length;
|
||||
}
|
||||
acquire() {
|
||||
const eventId = this.eventId++;
|
||||
this._executeEventHandlers('acquireRequest', eventId);
|
||||
const pendingAcquire = new PendingOperation_1.PendingOperation(this.acquireTimeoutMillis);
|
||||
this.pendingAcquires.push(pendingAcquire);
|
||||
// If the acquire fails for whatever reason
|
||||
// remove it from the pending queue.
|
||||
pendingAcquire.promise = pendingAcquire.promise
|
||||
.then(resource => {
|
||||
this._executeEventHandlers('acquireSuccess', eventId, resource);
|
||||
return resource;
|
||||
})
|
||||
.catch(err => {
|
||||
this._executeEventHandlers('acquireFail', eventId, err);
|
||||
remove(this.pendingAcquires, pendingAcquire);
|
||||
return Promise.reject(err);
|
||||
});
|
||||
this._tryAcquireOrCreate();
|
||||
return pendingAcquire;
|
||||
}
|
||||
release(resource) {
|
||||
this._executeEventHandlers('release', resource);
|
||||
for (let i = 0, l = this.used.length; i < l; ++i) {
|
||||
const used = this.used[i];
|
||||
if (used.resource === resource) {
|
||||
this.used.splice(i, 1);
|
||||
this.free.push(used.resolve());
|
||||
this._tryAcquireOrCreate();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
isEmpty() {
|
||||
return ([
|
||||
this.numFree(),
|
||||
this.numUsed(),
|
||||
this.numPendingAcquires(),
|
||||
this.numPendingValidations(),
|
||||
this.numPendingCreates()
|
||||
].reduce((total, value) => total + value) === 0);
|
||||
}
|
||||
/**
|
||||
* Reaping cycle.
|
||||
*/
|
||||
check() {
|
||||
const timestamp = utils_1.now();
|
||||
const newFree = [];
|
||||
const minKeep = this.min - this.used.length;
|
||||
const maxDestroy = this.free.length - minKeep;
|
||||
let numDestroyed = 0;
|
||||
this.free.forEach(free => {
|
||||
if (utils_1.duration(timestamp, free.timestamp) >= this.idleTimeoutMillis &&
|
||||
numDestroyed < maxDestroy) {
|
||||
numDestroyed++;
|
||||
this._destroy(free.resource);
|
||||
}
|
||||
else {
|
||||
newFree.push(free);
|
||||
}
|
||||
});
|
||||
this.free = newFree;
|
||||
// Pool is completely empty, stop reaping.
|
||||
// Next .acquire will start reaping interval again.
|
||||
if (this.isEmpty()) {
|
||||
this._stopReaping();
|
||||
}
|
||||
}
|
||||
destroy() {
|
||||
const eventId = this.eventId++;
|
||||
this._executeEventHandlers('poolDestroyRequest', eventId);
|
||||
this._stopReaping();
|
||||
this.destroyed = true;
|
||||
// First wait for all the pending creates get ready.
|
||||
return utils_1.reflect(Promise.all(this.pendingCreates.map(create => utils_1.reflect(create.promise)))
|
||||
.then(() => {
|
||||
// eslint-disable-next-line
|
||||
return new Promise((resolve, reject) => {
|
||||
// poll every 100ms and wait that all validations are ready
|
||||
if (this.numPendingValidations() === 0) {
|
||||
resolve();
|
||||
return;
|
||||
}
|
||||
const interval = setInterval(() => {
|
||||
if (this.numPendingValidations() === 0) {
|
||||
timers_1.clearInterval(interval);
|
||||
resolve();
|
||||
}
|
||||
}, 100);
|
||||
});
|
||||
})
|
||||
.then(() => {
|
||||
// Wait for all the used resources to be freed.
|
||||
return Promise.all(this.used.map(used => utils_1.reflect(used.promise)));
|
||||
})
|
||||
.then(() => {
|
||||
// Abort all pending acquires.
|
||||
return Promise.all(this.pendingAcquires.map(acquire => {
|
||||
acquire.abort();
|
||||
return utils_1.reflect(acquire.promise);
|
||||
}));
|
||||
})
|
||||
.then(() => {
|
||||
// Now we can destroy all the freed resources.
|
||||
return Promise.all(this.free.map(free => utils_1.reflect(this._destroy(free.resource))));
|
||||
})
|
||||
.then(() => {
|
||||
// Also wait rest of the pending destroys to finish
|
||||
return Promise.all(this.pendingDestroys.map(pd => pd.promise));
|
||||
})
|
||||
.then(() => {
|
||||
this.free = [];
|
||||
this.pendingAcquires = [];
|
||||
})).then(res => {
|
||||
this._executeEventHandlers('poolDestroySuccess', eventId);
|
||||
this.emitter.removeAllListeners();
|
||||
return res;
|
||||
});
|
||||
}
|
||||
on(event, listener) {
|
||||
this.emitter.on(event, listener);
|
||||
}
|
||||
removeListener(event, listener) {
|
||||
this.emitter.removeListener(event, listener);
|
||||
}
|
||||
removeAllListeners(event) {
|
||||
this.emitter.removeAllListeners(event);
|
||||
}
|
||||
/**
|
||||
* The most important method that is called always when resources
|
||||
* are created / destroyed / acquired / released. In other words
|
||||
* every time when resources are moved from used to free or vice
|
||||
* versa.
|
||||
*
|
||||
* Either assigns free resources to pendingAcquires or creates new
|
||||
* resources if there is room for it in the pool.
|
||||
*/
|
||||
_tryAcquireOrCreate() {
|
||||
if (this.destroyed) {
|
||||
return;
|
||||
}
|
||||
if (this._hasFreeResources()) {
|
||||
this._doAcquire();
|
||||
}
|
||||
else if (this._shouldCreateMoreResources()) {
|
||||
this._doCreate();
|
||||
}
|
||||
}
|
||||
_hasFreeResources() {
|
||||
return this.free.length > 0;
|
||||
}
|
||||
_doAcquire() {
|
||||
// Acquire as many pending acquires as possible concurrently
|
||||
while (this._canAcquire()) {
|
||||
// To allow async validation, we actually need to move free resource
|
||||
// and pending acquire temporary from their respective arrays and depending
|
||||
// on validation result to either leave the free resource to used resources array
|
||||
// or destroy the free resource if validation did fail.
|
||||
const pendingAcquire = this.pendingAcquires.shift();
|
||||
const free = this.free.pop();
|
||||
if (free === undefined || pendingAcquire === undefined) {
|
||||
const errMessage = 'this.free was empty while trying to acquire resource';
|
||||
this.log(`Tarn: ${errMessage}`, 'warn');
|
||||
throw new Error(`Internal error, should never happen. ${errMessage}`);
|
||||
}
|
||||
// Make sure that pendingAcquire that is being validated is not lost and
|
||||
// can be freed when pool is destroyed.
|
||||
this.pendingValidations.push(pendingAcquire);
|
||||
// Must be added here pre-emptively to prevent logic that decides
|
||||
// if new resources are created will keep on working correctly.
|
||||
this.used.push(free);
|
||||
// if acquire fails also pending validation, must be aborted so that pre reserved
|
||||
// resource will be returned to free resources immediately
|
||||
const abortAbleValidation = new PendingOperation_1.PendingOperation(this.acquireTimeoutMillis);
|
||||
// eslint-disable-next-line
|
||||
pendingAcquire.promise.catch(err => {
|
||||
abortAbleValidation.abort();
|
||||
});
|
||||
abortAbleValidation.promise
|
||||
.catch(err => {
|
||||
// There's nothing we can do here but log the error. This would otherwise
|
||||
// leak out as an unhandled exception.
|
||||
this.log('Tarn: resource validator threw an exception ' + err.stack, 'warn');
|
||||
return false;
|
||||
})
|
||||
.then(validationSuccess => {
|
||||
try {
|
||||
if (validationSuccess && !pendingAcquire.isRejected) {
|
||||
// At least one active resource exist, start reaping.
|
||||
this._startReaping();
|
||||
pendingAcquire.resolve(free.resource);
|
||||
}
|
||||
else {
|
||||
remove(this.used, free);
|
||||
// Only destroy the resource if the validation has failed
|
||||
if (!validationSuccess) {
|
||||
this._destroy(free.resource);
|
||||
// Since we destroyed an invalid resource and were not able to fulfill
|
||||
// all the pending acquires, we may need to create new ones or at
|
||||
// least run this acquire loop again to verify it. But not immediately
|
||||
// to prevent starving event loop.
|
||||
setTimeout(() => {
|
||||
this._tryAcquireOrCreate();
|
||||
}, 0);
|
||||
}
|
||||
else {
|
||||
this.free.push(free);
|
||||
}
|
||||
// is acquire was canceled, failed or timed out already
|
||||
// no need to return it to pending queries
|
||||
if (!pendingAcquire.isRejected) {
|
||||
this.pendingAcquires.unshift(pendingAcquire);
|
||||
}
|
||||
}
|
||||
}
|
||||
finally {
|
||||
remove(this.pendingValidations, pendingAcquire);
|
||||
}
|
||||
});
|
||||
// try to validate
|
||||
this._validateResource(free.resource)
|
||||
.then(validationSuccess => {
|
||||
abortAbleValidation.resolve(validationSuccess);
|
||||
})
|
||||
.catch(err => {
|
||||
abortAbleValidation.reject(err);
|
||||
});
|
||||
}
|
||||
}
|
||||
_canAcquire() {
|
||||
return this.free.length > 0 && this.pendingAcquires.length > 0;
|
||||
}
|
||||
_validateResource(resource) {
|
||||
try {
|
||||
return Promise.resolve(this.validate(resource));
|
||||
}
|
||||
catch (err) {
|
||||
// prevent leaking of sync exception
|
||||
return Promise.reject(err);
|
||||
}
|
||||
}
|
||||
_shouldCreateMoreResources() {
|
||||
return (this.used.length + this.pendingCreates.length < this.max &&
|
||||
this.pendingCreates.length < this.pendingAcquires.length);
|
||||
}
|
||||
_doCreate() {
|
||||
const pendingAcquiresBeforeCreate = this.pendingAcquires.slice();
|
||||
const pendingCreate = this._create();
|
||||
pendingCreate.promise
|
||||
.then(() => {
|
||||
// Not returned on purpose.
|
||||
this._tryAcquireOrCreate();
|
||||
return null;
|
||||
})
|
||||
.catch(err => {
|
||||
if (this.propagateCreateError && this.pendingAcquires.length !== 0) {
|
||||
// If propagateCreateError is true, we don't retry the create
|
||||
// but reject the first pending acquire immediately. Intentionally
|
||||
// use `this.pendingAcquires` instead of `pendingAcquiresBeforeCreate`
|
||||
// in case some acquires in pendingAcquiresBeforeCreate have already
|
||||
// been resolved.
|
||||
this.pendingAcquires[0].reject(err);
|
||||
}
|
||||
// Save the create error to all pending acquires so that we can use it
|
||||
// as the error to reject the acquire if it times out.
|
||||
pendingAcquiresBeforeCreate.forEach(pendingAcquire => {
|
||||
pendingAcquire.possibleTimeoutCause = err;
|
||||
});
|
||||
// Not returned on purpose.
|
||||
utils_1.delay(this.createRetryIntervalMillis).then(() => this._tryAcquireOrCreate());
|
||||
});
|
||||
}
|
||||
_create() {
|
||||
const eventId = this.eventId++;
|
||||
this._executeEventHandlers('createRequest', eventId);
|
||||
const pendingCreate = new PendingOperation_1.PendingOperation(this.createTimeoutMillis);
|
||||
// If an error occurs (likely a create timeout) remove this creation from
|
||||
// the list of pending creations so we try to create a new one.
|
||||
pendingCreate.promise = pendingCreate.promise.catch(err => {
|
||||
if (remove(this.pendingCreates, pendingCreate)) {
|
||||
// TODO: figure out more consistent way for different error handlers in next rewrite
|
||||
this._executeEventHandlers('createFail', eventId, err);
|
||||
}
|
||||
throw err;
|
||||
});
|
||||
this.pendingCreates.push(pendingCreate);
|
||||
callbackOrPromise(this.creator)
|
||||
.then(resource => {
|
||||
if (pendingCreate.isRejected) {
|
||||
this.destroyer(resource);
|
||||
return null;
|
||||
}
|
||||
remove(this.pendingCreates, pendingCreate);
|
||||
this.free.push(new Resource_1.Resource(resource));
|
||||
// Not returned on purpose.
|
||||
pendingCreate.resolve(resource);
|
||||
this._executeEventHandlers('createSuccess', eventId, resource);
|
||||
return null;
|
||||
})
|
||||
.catch(err => {
|
||||
if (pendingCreate.isRejected) {
|
||||
return null;
|
||||
}
|
||||
if (remove(this.pendingCreates, pendingCreate)) {
|
||||
this._executeEventHandlers('createFail', eventId, err);
|
||||
}
|
||||
// Not returned on purpose.
|
||||
pendingCreate.reject(err);
|
||||
return null;
|
||||
});
|
||||
return pendingCreate;
|
||||
}
|
||||
_destroy(resource) {
|
||||
const eventId = this.eventId++;
|
||||
this._executeEventHandlers('destroyRequest', eventId, resource);
|
||||
// this.destroyer can be both synchronous and asynchronous.
|
||||
// so we wrap it to promise to get all exceptions through same pipeline
|
||||
const pendingDestroy = new PendingOperation_1.PendingOperation(this.destroyTimeoutMillis);
|
||||
const retVal = Promise.resolve().then(() => this.destroyer(resource));
|
||||
retVal
|
||||
.then(() => {
|
||||
pendingDestroy.resolve(resource);
|
||||
})
|
||||
.catch((err) => {
|
||||
pendingDestroy.reject(err);
|
||||
});
|
||||
this.pendingDestroys.push(pendingDestroy);
|
||||
// In case of an error there's nothing we can do here but log it.
|
||||
return pendingDestroy.promise
|
||||
.then(res => {
|
||||
this._executeEventHandlers('destroySuccess', eventId, resource);
|
||||
return res;
|
||||
})
|
||||
.catch(err => this._logDestroyerError(eventId, resource, err))
|
||||
.then(res => {
|
||||
const index = this.pendingDestroys.findIndex(pd => pd === pendingDestroy);
|
||||
this.pendingDestroys.splice(index, 1);
|
||||
return res;
|
||||
});
|
||||
}
|
||||
_logDestroyerError(eventId, resource, err) {
|
||||
this._executeEventHandlers('destroyFail', eventId, resource, err);
|
||||
this.log('Tarn: resource destroyer threw an exception ' + err.stack, 'warn');
|
||||
}
|
||||
_startReaping() {
|
||||
if (!this.interval) {
|
||||
this._executeEventHandlers('startReaping');
|
||||
this.interval = setInterval(() => this.check(), this.reapIntervalMillis);
|
||||
}
|
||||
}
|
||||
_stopReaping() {
|
||||
if (this.interval !== null) {
|
||||
this._executeEventHandlers('stopReaping');
|
||||
timers_1.clearInterval(this.interval);
|
||||
}
|
||||
this.interval = null;
|
||||
}
|
||||
_executeEventHandlers(eventName, ...args) {
|
||||
const listeners = this.emitter.listeners(eventName);
|
||||
// just calling .emit() would stop running rest of the listeners if one them fails
|
||||
listeners.forEach(listener => {
|
||||
try {
|
||||
listener(...args);
|
||||
}
|
||||
catch (err) {
|
||||
// There's nothing we can do here but log the error. This would otherwise
|
||||
// leak out as an unhandled exception.
|
||||
this.log(`Tarn: event handler "${eventName}" threw an exception ${err.stack}`, 'warn');
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
exports.Pool = Pool;
|
||||
function remove(arr, item) {
|
||||
const idx = arr.indexOf(item);
|
||||
if (idx === -1) {
|
||||
return false;
|
||||
}
|
||||
else {
|
||||
arr.splice(idx, 1);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
function callbackOrPromise(func) {
|
||||
return new Promise((resolve, reject) => {
|
||||
const callback = (err, resource) => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
}
|
||||
else {
|
||||
resolve(resource);
|
||||
}
|
||||
};
|
||||
utils_1.tryPromise(() => func(callback))
|
||||
.then(res => {
|
||||
// If the result is falsy, we assume that the callback will
|
||||
// be called instead of interpreting the falsy value as a
|
||||
// result value.
|
||||
if (res) {
|
||||
resolve(res);
|
||||
}
|
||||
})
|
||||
.catch(err => {
|
||||
reject(err);
|
||||
});
|
||||
});
|
||||
}
|
||||
Reference in New Issue
Block a user