redis-smq
Version:
A high-performance, reliable, and scalable message queue for Node.js.
137 lines • 6.07 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.LifecycleManager = void 0;
const redis_smq_common_1 = require("redis-smq-common");
const configuration_js_1 = require("../config-manager/configuration.js");
const redis_connection_pool_js_1 = require("../common/redis/redis-connection-pool/redis-connection-pool.js");
const internal_event_bus_js_1 = require("../event-bus/internal-event-bus.js");
const background_job_cluster_js_1 = require("../common/background-jobs/background-job-cluster.js");
const state_manager_js_1 = require("./state-manager.js");
const component_registry_js_1 = require("./component-registry.js");
const index_js_1 = require("../event-bus/index.js");
const event_multiplexer_js_1 = require("../event-bus/event-multiplexer.js");
const config_sync_js_1 = require("../config-manager/config-sync.js");
const redis_config_js_1 = require("../common/redis/redis-config.js");
class LifecycleManager {
static initialize(...args) {
let cb = undefined;
let redisConfig = undefined;
if (args.length === 1) {
if (typeof args[0] === 'function')
cb = args[0];
else
redisConfig = args[0];
}
if (args.length === 2) {
if (typeof args[0] === 'object')
redisConfig = args[0];
if (typeof args[1] === 'function')
cb = args[1];
}
return redis_smq_common_1.async.withOptionalCallback(cb, (callback) => {
if (state_manager_js_1.StateManager.isUp()) {
return callback();
}
if (state_manager_js_1.StateManager.isGoingUp()) {
LifecycleManager.initWaiters.push(callback);
return;
}
if (state_manager_js_1.StateManager.isGoingDown()) {
return callback(new redis_smq_common_1.PanicError({ message: 'RedisSMQ is shutting down' }));
}
state_manager_js_1.StateManager.goingUp();
redis_config_js_1.RedisConfig.initialize(redisConfig);
redis_smq_common_1.async.series([
(cb) => {
const config = redis_config_js_1.RedisConfig.getConfig();
redis_connection_pool_js_1.RedisConnectionPool.initialize(config, {}, (err) => cb(err));
},
(cb) => {
configuration_js_1.Configuration.initialize(cb);
},
(cb) => {
internal_event_bus_js_1.InternalEventBus.getInstance().run(cb);
},
(cb) => {
config_sync_js_1.ConfigSync.initialize(cb);
},
(cb) => {
background_job_cluster_js_1.BackgroundJobCluster.run(cb);
},
], (err) => {
if (err)
state_manager_js_1.StateManager.rollback();
else
state_manager_js_1.StateManager.commit();
const waiters = LifecycleManager.initWaiters.splice(0);
waiters.forEach((w) => w(err));
callback(err);
});
});
}
static shutdown(cb) {
return redis_smq_common_1.async.withOptionalCallback(cb, (callback) => {
if (state_manager_js_1.StateManager.isGoingDown()) {
LifecycleManager.shutdownWaiters.push(callback);
return;
}
if (state_manager_js_1.StateManager.isGoingUp()) {
return callback(new redis_smq_common_1.PanicError({ message: 'Cannot shutdown while initializing' }));
}
if (state_manager_js_1.StateManager.isDown() && component_registry_js_1.ComponentRegistry.size === 0) {
return callback();
}
state_manager_js_1.StateManager.goingDown();
const errors = [];
redis_smq_common_1.async.series([
(cb) => background_job_cluster_js_1.BackgroundJobCluster.shutdown(cb),
(cb) => component_registry_js_1.ComponentRegistry.shutdownComponents((err) => {
if (err)
errors.push(err);
cb();
}),
(cb) => config_sync_js_1.ConfigSync.shutdown(cb),
(cb) => configuration_js_1.Configuration.shutdown((err) => {
if (err)
errors.push(err);
cb();
}),
(cb) => index_js_1.EventBus.shutdown((err) => {
if (err)
errors.push(err);
cb();
}),
(cb) => internal_event_bus_js_1.InternalEventBus.shutdown((err) => {
if (err)
errors.push(err);
cb();
}),
(cb) => event_multiplexer_js_1.EventMultiplexer.shutdown((err) => {
if (err)
errors.push(err);
cb();
}),
(cb) => redis_connection_pool_js_1.RedisConnectionPool.shutdown((err) => {
if (err)
errors.push(err);
cb();
}),
], () => {
state_manager_js_1.StateManager.commit();
component_registry_js_1.ComponentRegistry.clear();
redis_config_js_1.RedisConfig.reset();
const waiters = LifecycleManager.shutdownWaiters.splice(0);
const firstErr = errors[0] || null;
callback(firstErr);
waiters.forEach((w) => w(firstErr));
});
});
}
}
exports.LifecycleManager = LifecycleManager;
LifecycleManager.shutdownWaiters = [];
LifecycleManager.initWaiters = [];
LifecycleManager.isRunning = () => {
return state_manager_js_1.StateManager.isRunning();
};
//# sourceMappingURL=lifecycle-manager.js.map