Re: [D] In nodejs, the SimpleConsumer receive method cannot guarantee that messages are obtained in order? [rocketmq]

[via GitHub]

GitHub user JanYork closed a discussion: In nodejs, the SimpleConsumer receive 
method cannot guarantee that messages are obtained in order?

my consumer code：

```js
require('module-alias/register');

import { SimpleConsumer } from '@/consumer';

const consumer = new SimpleConsumer({
  consumerGroup: 'checkout-group',
  endpoints: '192.168.1.162:8081',
  subscriptions: new Map().set('checkout-topic-fifo', '*'),
  requestTimeout: 3000,
  awaitDuration: 30000 // long polling
});

console.log('checkout：consumer init success!');

const isShutdown = false;

async function startAndConsumeMessages() {
  try {
    await consumer.startup();
    console.log('checkout：consumer startup success!');

    async function consumeMessages() {
      try {
        const messages = await consumer.receive(10);

        if (messages.length > 0) {
          console.log('got %d messages', messages.length);

          for (const message of messages) {
            console.log('body=%o', message.body.toString());
            await consumer.ack(message);
          }
        } else {
          console.log('No messages received, waiting...');
        }
      } catch (error) {
        console.error('An error occurred:', error);
      } finally {
        console.log('checkout：waiting for messages...');

        if (!isShutdown) {
          await consumeMessages();
        }
      }
    }

    await consumeMessages();
  } catch (error) {
    console.error('An error occurred:', error);
  } finally {
    // ...
  }
}

startAndConsumeMessages().catch(console.error);
```

my producer code：

```js
require('module-alias/register');

import { Producer } from '@/producer';

const fifoProducer = new Producer({
  endpoints: 'localhost:8081'
});
console.log('checkout：simpleProducer init success!');

(async () => {
  fifoProducer.startup().then(async () => {
    console.log('checkout：simpleProducer startup success!');

    for (let i = 1; i <= 10; i++) {
      await fifoProducer.send({
        messageGroup: 'checkout-group',
        topic: 'checkout-topic-fifo',
        tag: 'checkout',
        keys: ['checkout-key'],
        body: Buffer.from(i.toString())
      });

      console.log('message %d sent', i);
      console.log('checkout：send message success!');
    }

    process.exit(0);
  });
})();
```

Producer execution log：
```
message 1 sent
checkout：send message success!
message 2 sent
checkout：send message success!
message 3 sent
checkout：send message success!
message 4 sent
checkout：send message success!
message 5 sent
checkout：send message success!
message 6 sent
checkout：send message success!
message 7 sent
checkout：send message success!
message 8 sent
checkout：send message success!
message 9 sent
checkout：send message success!
message 10 sent
checkout：send message success!
```

Consumer execution log：
```
checkout：consumer startup success!
got 10 messages
body='2'
body='3'
body='4'
body='5'
body='6'
body='7'
body='8'
body='9'
body='10'
body='1'
checkout：waiting for messages...
```

It seems that this situation only occurs when the consumer obtains messages for 
the first time after startup. The order of monitoring messages thereafter is 
consistent.

Isn't the receive method an atomic method? My Topic type is FIFO, and my 
messages are produced to the same group in order, but the receive method does 
not guarantee the order when it gets the message for the first time after the 
consumer starts, and only the first message does this.

GitHub link: https://github.com/apache/rocketmq/discussions/8113

----
This is an automatically sent email for dev@rocketmq.apache.org.
To unsubscribe, please send an email to: dev-unsubscr...@rocketmq.apache.org