Use different message types or different mboxes? about sobjectizer HOT 4 OPEN

Hi!

From my experience, one of the biggest problems in a case when you have to receive the same information from different sources (aka devices like sensors) is the identification of the source for an incoming message.

It's good when you can include some ID into a message. Something like:

struct msg_current_value : public so_5::message_t {
  sensor_id_t id_;
  value_t val_;
  ...
};

In that case just one mbox for all messages is enough.

But if you can't include the device's ID into a message then you can use a separate mbox for every device. In that case you can bind the ID with an incoming message during the subscription. Something like:

so_subscribe(unique_device_mbox)
  .event( [this, unique_device_id]( mhood_t<msg_current_value> cmd) {
    on_current_value(unique_device_id, std::move(cmd));
  });
...

So I think that you have to consider the usage of different mboxes in case when you can't put device ID into your messages. If you can do that then the single mbox for all messages can be a simpler solution.

There is yet another factor that you can consider: separate mboxes are often used when you have to create and remove your subscriptions in run-time. For example, at some moment of time an agent wants to receive messages from device_A -- it creates a new subscription to the unique mbox of that device. When the agent decides that it doesn't want to receive messages from that device then the subscription from the device mbox is just dropped. And that doesn't affect subscriptions to mboxes of other devices.

If you want such a possibility then you can consider the usage of different mboxes. But if not then the use of the single mbox can be a simpler solution.

Hope that will be useful information for you. If not, feel free to ask more.

from sobjectizer.

Thanks for the prompt response. I think a single mailbox for all devices is good, because the MQTT translation code can extract the device name from the topic name and embed that into the message. So the question regarding how to handle the devices is solved.

What remains is how to handle the different message types, i.e., if the devices send and receive different parameters which could in principle be represented by the same class (e.g. "device1/measurementA", "device1/measurementB", "device1/setpoint", "device1/limit"). If I were to use the same class for those messages, then I would need to use different mboxes (e.g "AllDevices/measurementA", "AllDevices/measurementB", etc). On the other hand, I could create "dummy" subclasses and that would allow me to use the same mbox for all parameters.

e.g. I could do something like:

struct base_sensor_message : public so_5::message_t {
  sensor_id_t id_;
  value_t val_;
};

struct measurement_a : public base_sensor_message {};

struct measurement_b : public base_sensor_message {};

struct setpoint : public base_sensor_message {};

..etc..

Since I'm not familiar with the library, I don't know which one is the better approach.

from sobjectizer.

I usually use the approach with a base class with empty subclasses, just like you showed in the code example.

from sobjectizer.

@eao197 Thank you very much.

from sobjectizer.