rocketmq-client-nodejs-bate 1.0.12

package/dist/consumer/ProcessQueue.js

@@ -0,0 +1,286 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessQueue = void 0;
+const node_crypto_1 = require("node:crypto");
+const definition_pb_1 = require("../../proto/apache/rocketmq/v2/definition_pb");
+const exception_1 = require("../exception");
+const ConsumeResult_1 = require("./ConsumeResult");
+const ACK_MESSAGE_FAILURE_BACKOFF_DELAY = 1000;
+const CHANGE_INVISIBLE_DURATION_FAILURE_BACKOFF_DELAY = 1000;
+const FORWARD_MESSAGE_TO_DLQ_FAILURE_BACKOFF_DELAY = 1000;
+const RECEIVING_FLOW_CONTROL_BACKOFF_DELAY = 20;
+const RECEIVING_FAILURE_BACKOFF_DELAY = 1000;
+const RECEIVING_BACKOFF_DELAY_WHEN_CACHE_IS_FULL = 1000;
+class ProcessQueue {
+    #consumer;
+    #dropped = false;
+    #mq;
+    #filterExpression;
+    #cachedMessages = [];
+    #cachedMessagesBytes = 0;
+    #activityTime = Date.now();
+    #cacheFullTime = 0;
+    #aborted = false;
+    constructor(consumer, mq, filterExpression) {
+        this.#consumer = consumer;
+        this.#mq = mq;
+        this.#filterExpression = filterExpression;
+    }
+    getMessageQueue() {
+        return this.#mq;
+    }
+    drop() {
+        this.#dropped = true;
+    }
+    expired() {
+        const longPollingTimeout = this.#consumer.getPushConsumerSettings().getLongPollingTimeout();
+        const requestTimeout = this.#consumer.requestTimeoutValue;
+        const maxIdleDuration = (longPollingTimeout + requestTimeout) * 3;
+        const idleDuration = Date.now() - this.#activityTime;
+        if (idleDuration < maxIdleDuration) {
+            return false;
+        }
+        const afterCacheFullDuration = Date.now() - this.#cacheFullTime;
+        if (afterCacheFullDuration < maxIdleDuration) {
+            return false;
+        }
+        return true;
+    }
+    cacheMessages(messageList) {
+        for (const messageView of messageList) {
+            this.#cachedMessages.push(messageView);
+            this.#cachedMessagesBytes += messageView.body.length;
+        }
+    }
+    #getReceptionBatchSize() {
+        const bufferSize = Math.max(this.#consumer.cacheMessageCountThresholdPerQueue() - this.cachedMessagesCount(), 1);
+        return Math.min(bufferSize, this.#consumer.getPushConsumerSettings().getReceiveBatchSize());
+    }
+    fetchMessageImmediately() {
+        this.#receiveMessageImmediately();
+    }
+    onReceiveMessageException(t, attemptId) {
+        const delay = t instanceof exception_1.TooManyRequestsException
+            ? RECEIVING_FLOW_CONTROL_BACKOFF_DELAY
+            : RECEIVING_FAILURE_BACKOFF_DELAY;
+        this.#receiveMessageLater(delay, attemptId);
+    }
+    #receiveMessageLater(delay, attemptId) {
+        if (this.#aborted)
+            return;
+        setTimeout(() => {
+            if (this.#aborted)
+                return;
+            this.#receiveMessage(attemptId);
+        }, delay);
+    }
+    #generateAttemptId() {
+        return (0, node_crypto_1.randomUUID)();
+    }
+    receiveMessage(attemptId) {
+        this.#receiveMessage(attemptId);
+    }
+    #receiveMessage(attemptId) {
+        if (this.#dropped) {
+            return;
+        }
+        if (this.#isCacheFull()) {
+            this.#receiveMessageLater(RECEIVING_BACKOFF_DELAY_WHEN_CACHE_IS_FULL, attemptId);
+            return;
+        }
+        this.#receiveMessageImmediately(attemptId);
+    }
+    #receiveMessageImmediately(attemptId) {
+        if (this.#aborted)
+            return;
+        attemptId = attemptId ?? this.#generateAttemptId();
+        try {
+            const batchSize = this.#getReceptionBatchSize();
+            const longPollingTimeout = this.#consumer.getPushConsumerSettings().getLongPollingTimeout();
+            const request = this.#consumer.wrapPushReceiveMessageRequest(batchSize, this.#mq, this.#filterExpression, longPollingTimeout, attemptId);
+            this.#activityTime = Date.now();
+            this.#consumer.receiveMessage(request, this.#mq, longPollingTimeout)
+                .then(messages => {
+                this.#onReceiveMessageResult(messages);
+            })
+                .catch(err => {
+                this.onReceiveMessageException(err, attemptId);
+            });
+        }
+        catch (err) {
+            this.onReceiveMessageException(err, attemptId);
+        }
+    }
+    #onReceiveMessageResult(messages) {
+        if (messages.length > 0) {
+            this.cacheMessages(messages);
+            this.#consumer.getConsumeService().consume(this, messages);
+        }
+        this.#receiveMessage();
+    }
+    #isCacheFull() {
+        const cacheMessageCountThreshold = this.#consumer.cacheMessageCountThresholdPerQueue();
+        const actualCount = this.cachedMessagesCount();
+        if (cacheMessageCountThreshold <= actualCount) {
+            this.#cacheFullTime = Date.now();
+            return true;
+        }
+        const cacheMessageBytesThreshold = this.#consumer.cacheMessageBytesThresholdPerQueue();
+        if (cacheMessageBytesThreshold <= this.#cachedMessagesBytes) {
+            this.#cacheFullTime = Date.now();
+            return true;
+        }
+        return false;
+    }
+    eraseMessage(messageView, consumeResult) {
+        const task = consumeResult === ConsumeResult_1.ConsumeResult.SUCCESS
+            ? this.#ackMessage(messageView)
+            : this.#nackMessage(messageView);
+        task.finally(() => {
+            this.#evictCache(messageView);
+        });
+    }
+    async #ackMessage(messageView, attempt = 1) {
+        try {
+            const endpoints = messageView.endpoints;
+            const response = await this.#consumer.ackMessageViaRpc(endpoints, this.#consumer.wrapAckMessageRequest(messageView), this.#consumer.requestTimeoutValue);
+            const status = response.getStatus()?.toObject();
+            if (status?.code === definition_pb_1.Code.INVALID_RECEIPT_HANDLE) {
+                return; // Forgive to retry
+            }
+            if (status?.code !== definition_pb_1.Code.OK) {
+                await this.#ackMessageLater(messageView, attempt + 1);
+            }
+        }
+        catch {
+            await this.#ackMessageLater(messageView, attempt + 1);
+        }
+    }
+    async #ackMessageLater(messageView, attempt) {
+        if (this.#aborted)
+            return;
+        await new Promise(resolve => setTimeout(resolve, ACK_MESSAGE_FAILURE_BACKOFF_DELAY));
+        if (this.#aborted)
+            return;
+        await this.#ackMessage(messageView, attempt);
+    }
+    async #nackMessage(messageView) {
+        const retryPolicy = this.#consumer.getRetryPolicy();
+        const delay = retryPolicy?.getNextAttemptDelay(messageView.deliveryAttempt ?? 1) ?? 0;
+        await this.#changeInvisibleDuration(messageView, delay);
+    }
+    async #changeInvisibleDuration(messageView, duration, attempt = 1) {
+        try {
+            const endpoints = messageView.endpoints;
+            const response = await this.#consumer.changeInvisibleDurationViaRpc(endpoints, this.#consumer.wrapChangeInvisibleDurationRequest(messageView, duration), this.#consumer.requestTimeoutValue);
+            const status = response.getStatus()?.toObject();
+            if (status?.code === definition_pb_1.Code.INVALID_RECEIPT_HANDLE) {
+                return; // Forgive to retry
+            }
+            if (status?.code !== definition_pb_1.Code.OK) {
+                await this.#changeInvisibleDurationLater(messageView, duration, attempt + 1);
+            }
+        }
+        catch {
+            await this.#changeInvisibleDurationLater(messageView, duration, attempt + 1);
+        }
+    }
+    async #changeInvisibleDurationLater(messageView, duration, attempt) {
+        if (this.#aborted)
+            return;
+        await new Promise(resolve => setTimeout(resolve, CHANGE_INVISIBLE_DURATION_FAILURE_BACKOFF_DELAY));
+        if (this.#aborted)
+            return;
+        await this.#changeInvisibleDuration(messageView, duration, attempt);
+    }
+    async eraseFifoMessage(messageView, consumeResult) {
+        const retryPolicy = this.#consumer.getRetryPolicy();
+        const maxAttempts = retryPolicy?.getMaxAttempts() ?? 1;
+        let attempt = messageView.deliveryAttempt ?? 1;
+        if (consumeResult === ConsumeResult_1.ConsumeResult.FAILURE && attempt < maxAttempts) {
+            const nextAttemptDelay = retryPolicy?.getNextAttemptDelay(attempt) ?? 0;
+            // Redeliver the fifo message
+            const result = await this.#consumer.getConsumeService().consumeMessage(messageView, nextAttemptDelay);
+            await this.eraseFifoMessage(messageView, result);
+        }
+        else {
+            const task = consumeResult === ConsumeResult_1.ConsumeResult.SUCCESS
+                ? this.#ackMessage(messageView)
+                : this.#forwardToDeadLetterQueue(messageView);
+            await task;
+            this.#evictCache(messageView);
+        }
+    }
+    async #forwardToDeadLetterQueue(messageView, attempt = 1) {
+        try {
+            const endpoints = messageView.endpoints;
+            const response = await this.#consumer.forwardMessageToDeadLetterQueueViaRpc(endpoints, this.#consumer.wrapForwardMessageToDeadLetterQueueRequest(messageView), this.#consumer.requestTimeoutValue);
+            const status = response.getStatus();
+            if (!status) {
+                throw new Error('Missing status in forward to dead letter queue response');
+            }
+            const statusObj = status.toObject();
+            if (statusObj.code !== definition_pb_1.Code.OK) {
+                await this.#forwardToDeadLetterQueueLater(messageView, attempt + 1);
+            }
+        }
+        catch (err) {
+            if (err.message === 'Missing status in forward to dead letter queue response') {
+                throw err; // Re-throw critical error
+            }
+            await this.#forwardToDeadLetterQueueLater(messageView, attempt + 1);
+        }
+    }
+    async #forwardToDeadLetterQueueLater(messageView, attempt) {
+        if (this.#aborted)
+            return;
+        await new Promise(resolve => setTimeout(resolve, FORWARD_MESSAGE_TO_DLQ_FAILURE_BACKOFF_DELAY));
+        if (this.#aborted)
+            return;
+        await this.#forwardToDeadLetterQueue(messageView, attempt);
+    }
+    discardMessage(messageView) {
+        this.#nackMessage(messageView).finally(() => {
+            this.#evictCache(messageView);
+        });
+    }
+    discardFifoMessage(messageView) {
+        this.#forwardToDeadLetterQueue(messageView).finally(() => {
+            this.#evictCache(messageView);
+        });
+    }
+    #evictCache(messageView) {
+        const index = this.#cachedMessages.indexOf(messageView);
+        if (index !== -1) {
+            this.#cachedMessages.splice(index, 1);
+            this.#cachedMessagesBytes -= messageView.body.length;
+        }
+    }
+    cachedMessagesCount() {
+        return this.#cachedMessages.length;
+    }
+    cachedMessageBytes() {
+        return this.#cachedMessagesBytes;
+    }
+    abort() {
+        this.#aborted = true;
+    }
+}
+exports.ProcessQueue = ProcessQueue;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ProcessQueue.js","sourceRoot":"","sources":["../../src/consumer/ProcessQueue.ts"],"names":[],"mappings":"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"}

package/dist/consumer/PushConsumer.d.ts

@@ -0,0 +1,68 @@
+/**
+ * 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 { AckMessageRequest, ChangeInvisibleDurationRequest, ForwardMessageToDeadLetterQueueRequest, HeartbeatRequest, NotifyClientTerminationRequest, ReceiveMessageRequest } from '../../proto/apache/rocketmq/v2/service_pb';
+import { MessageView } from '../message';
+import { MessageQueue, TopicRouteData } from '../route';
+import { RetryPolicy } from '../retry';
+import { Consumer, ConsumerOptions } from './Consumer';
+import { FilterExpression } from './FilterExpression';
+import { PushSubscriptionSettings } from './PushSubscriptionSettings';
+import { ConsumeService } from './ConsumeService';
+import { MessageListener } from './MessageListener';
+export interface PushConsumerOptions extends ConsumerOptions {
+    subscriptions: Map<string, FilterExpression | string>;
+    messageListener: MessageListener;
+    maxCacheMessageCount?: number;
+    maxCacheMessageSizeInBytes?: number;
+    longPollingTimeout?: number;
+    enableFifoConsumeAccelerator?: boolean;
+}
+export declare class PushConsumer extends Consumer {
+    #private;
+    constructor(options: PushConsumerOptions);
+    startup(): Promise<void>;
+    shutdown(): Promise<void>;
+    protected getSettings(): PushSubscriptionSettings;
+    protected wrapHeartbeatRequest(): HeartbeatRequest;
+    protected wrapNotifyClientTerminationRequest(): NotifyClientTerminationRequest;
+    protected onTopicRouteDataUpdate(_topic: string, _topicRouteData: TopicRouteData): void;
+    subscribe(topic: string, filterExpression: FilterExpression): Promise<void>;
+    unsubscribe(topic: string): void;
+    get requestTimeoutValue(): number;
+    getPushConsumerSettings(): PushSubscriptionSettings;
+    getConsumerGroup(): string;
+    getConsumeService(): ConsumeService;
+    getRetryPolicy(): RetryPolicy | undefined;
+    getClientId(): string;
+    getReceptionTimes(): number;
+    getReceivedMessagesQuantity(): number;
+    getConsumptionOkQuantity(): number;
+    getConsumptionErrorQuantity(): number;
+    incrementReceptionTimes(): void;
+    incrementReceivedMessagesQuantity(count: number): void;
+    incrementConsumptionOkQuantity(): void;
+    incrementConsumptionErrorQuantity(): void;
+    doStats(): void;
+    wrapPushReceiveMessageRequest(batchSize: number, mq: MessageQueue, filterExpression: FilterExpression, longPollingTimeout: number, attemptId?: string): ReceiveMessageRequest;
+    receiveMessage(request: ReceiveMessageRequest, mq: MessageQueue, awaitDuration: number): Promise<MessageView[]>;
+    wrapAckMessageRequest(messageView: MessageView): AckMessageRequest;
+    wrapChangeInvisibleDurationRequest(messageView: MessageView, invisibleDuration: number): ChangeInvisibleDurationRequest;
+    wrapForwardMessageToDeadLetterQueueRequest(messageView: MessageView): ForwardMessageToDeadLetterQueueRequest;
+    getQueueSize(): number;
+    cacheMessageBytesThresholdPerQueue(): number;
+    cacheMessageCountThresholdPerQueue(): number;
+}