bpmn-elements
Version:
Executable workflow elements based on BPMN 2.0
201 lines (200 loc) • 7.27 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = CompensateEventDefinition;
var _shared = require("../shared.js");
var _messageHelper = require("../messageHelper.js");
const kCompleted = Symbol.for('completed');
const kExecuteMessage = Symbol.for('executeMessage');
const kMessageQ = Symbol.for('messageQ');
const kCompensateQ = Symbol.for('compensateQ');
const kAssociations = Symbol.for('associations');
function CompensateEventDefinition(activity, eventDefinition, context) {
const {
id,
broker,
environment,
isThrowing
} = activity;
this.id = id;
const type = this.type = eventDefinition.type;
const reference = this.reference = {
referenceType: 'compensate'
};
this.isThrowing = isThrowing;
this.activity = activity;
this.broker = broker;
this.logger = environment.Logger(type.toLowerCase());
if (!isThrowing) {
this[kCompleted] = false;
this[kAssociations] = context.getOutboundAssociations(id);
const messageQueueName = `${reference.referenceType}-${(0, _shared.brokerSafeId)(id)}-q`;
this[kMessageQ] = broker.assertQueue(messageQueueName, {
autoDelete: false,
durable: true
});
this[kCompensateQ] = broker.assertQueue('compensate-q', {
autoDelete: false,
durable: true
});
broker.bindQueue(messageQueueName, 'api', `*.${reference.referenceType}.#`, {
durable: true,
priority: 400
});
}
}
Object.defineProperty(CompensateEventDefinition.prototype, 'executionId', {
get() {
return this[kExecuteMessage]?.content.executionId;
}
});
CompensateEventDefinition.prototype.execute = function execute(executeMessage) {
return this.isThrowing ? this.executeThrow(executeMessage) : this.executeCatch(executeMessage);
};
CompensateEventDefinition.prototype.executeCatch = function executeCatch(executeMessage) {
this[kExecuteMessage] = executeMessage;
this[kCompleted] = false;
if (executeMessage.fields.routingKey === 'execute.compensating') {
this._debug('resumed at compensating');
this[kCompleted] = true;
return this._compensate();
}
const executeContent = executeMessage.content;
const {
executionId,
parent
} = executeContent;
this._debug('expect compensate');
const broker = this.broker;
broker.cancel('_convey-messages');
broker.assertExchange('compensate', 'topic');
broker.subscribeTmp('compensate', 'execute.#', this._onCollect.bind(this), {
noAck: true,
consumerTag: '_oncollect-messages'
});
this[kMessageQ].consume(this._onCompensateApiMessage.bind(this), {
noAck: true,
consumerTag: `_oncompensate-${executionId}`
});
if (this[kCompleted]) return;
broker.subscribeTmp('api', `activity.#.${parent.executionId}#`, this._onApiMessage.bind(this), {
noAck: true,
consumerTag: `_api-${executionId}`
});
broker.publish('execution', 'execute.detach', (0, _messageHelper.cloneContent)(executeContent, {
sourceExchange: 'execution',
bindExchange: 'compensate',
expect: 'compensate'
}));
};
CompensateEventDefinition.prototype.executeThrow = function executeThrow(executeMessage) {
const executeContent = executeMessage.content;
const {
parent
} = executeContent;
const parentExecutionId = parent?.executionId;
this.logger.debug(`<${parentExecutionId} (${this.id})> throw compensate`);
const broker = this.broker;
const throwContent = (0, _messageHelper.cloneContent)(executeContent, {
executionId: parentExecutionId,
state: 'throw'
});
throwContent.parent = (0, _messageHelper.shiftParent)(parent);
broker.publish('event', 'activity.compensate', throwContent, {
type: 'compensate',
delegate: true
});
return broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(executeContent));
};
CompensateEventDefinition.prototype._onCollect = function onCollect(routingKey, message) {
switch (routingKey) {
case 'execute.error':
case 'execute.completed':
{
return this[kCompensateQ].queueMessage(message.fields, (0, _messageHelper.cloneContent)(message.content), message.properties);
}
}
};
CompensateEventDefinition.prototype._onCompensateApiMessage = function onCompensateApiMessage(routingKey, message) {
this[kCompleted] = true;
const output = message.content.message;
const broker = this.broker;
const executeContent = this[kExecuteMessage].content;
this._stopCollect();
this._debug('caught compensate event');
const catchContent = (0, _messageHelper.cloneContent)(executeContent, {
message: {
...output
},
executionId: executeContent.parent.executionId
});
catchContent.parent = (0, _messageHelper.shiftParent)(catchContent.parent);
this[kCompensateQ].queueMessage({
routingKey: 'execute.compensated'
}, (0, _messageHelper.cloneContent)(executeContent));
broker.publish('execution', 'execute.compensating', (0, _messageHelper.cloneContent)(executeContent, {
message: {
...output
}
}));
broker.publish('event', 'activity.catch', catchContent, {
type: 'catch'
});
return this._compensate();
};
CompensateEventDefinition.prototype._compensate = function compensate() {
return this[kCompensateQ].consume(this._onCollected.bind(this), {
noAck: true,
consumerTag: '_convey-messages'
});
};
CompensateEventDefinition.prototype._onCollected = function onCollected(routingKey, message) {
if (routingKey === 'execute.compensated') {
const broker = this.broker;
broker.cancel('_convey-messages');
return this.broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(message.content, {
cancelActivity: false
}));
}
for (const association of this[kAssociations]) association.take((0, _messageHelper.cloneMessage)(message));
};
CompensateEventDefinition.prototype._onDiscardApiMessage = function onDiscardApiMessage(routingKey, message) {
this[kCompleted] = true;
this._stop();
this[kCompensateQ].purge();
for (const association of this[kAssociations]) association.discard((0, _messageHelper.cloneMessage)(message));
return this.broker.publish('execution', 'execute.discard', (0, _messageHelper.cloneContent)(this[kExecuteMessage].content));
};
CompensateEventDefinition.prototype._onApiMessage = function onApiMessage(routingKey, message) {
const messageType = message.properties.type;
switch (messageType) {
case 'compensate':
{
return this._onCompensateApiMessage(routingKey, message);
}
case 'discard':
{
return this._onDiscardApiMessage(routingKey, message);
}
case 'stop':
{
return this._stop();
}
}
};
CompensateEventDefinition.prototype._stopCollect = function stopCollect() {
const broker = this.broker,
executionId = this.executionId;
broker.cancel(`_api-${executionId}`);
broker.cancel(`_oncompensate-${executionId}`);
broker.cancel('_oncollect-messages');
this[kMessageQ].purge();
};
CompensateEventDefinition.prototype._stop = function stop() {
this._stopCollect();
this.broker.cancel('_convey-messages');
};
CompensateEventDefinition.prototype._debug = function debug(msg) {
this.logger.debug(`<${this.executionId} (${this.activity.id})> ${msg}`);
};