LXMF Synchronization between multiple devices with a shared identity

[khimaros]

a good starting point might be to come up with an example reticulum config that would produce the desired behavior. i'm willing to help with implementation once we have this.

from @markqvist in the matrix channel:

An interesting quality of Reticulum is that, partly because we don't use source addresses, and partly just because of the way Reticulum is put together, you can do stuff just fine that seems completely alien and counterintuitive in IP. Imagine two devices, that both have the same LXMF address. You can connect from one of them, to it's own LXMF address, on the other device. Then you just do a normal LXMF sync between them, and you have updated the conversations. This works for any number of devices, and the complete message store will eventually converge on all devices.

They don't even have to take turns being the instance that holds the active path to the LXMF address. As long as there is an active path to one "primary device", all other auxillary devices can eventually sync conversations through that device. If another device becomes the active path holder, syncing will just start occurring through that.

and some more context from @markqvist:

Letting different devices just not remove the messages from the propagation nodes is the most simple way of acheiving this. I think we also need to make sure that it happens in the context of letting devices themselves sync directly between each other, without having to use the propagation nodes.

Reticulum allows this already, ie., you can have the same LXMF address on several devices, and those that are not the currently active path owners will be able to connect directly to the one that is, and then sync messages. This needs a few things added to LXMF to work.

The reason I have not done this yet, is that it ties in very well with another feature we could call "sneakernet queues", where all mobile clients can act as a sort of physically moving propagation nodes, and sync message stores with each other when in close contact. This needs to be implemented so it only happens over fast interfaces though, as to not fill up slow LoRa/packet radio interfaces with unnecessary traffic.

the TODO here is one of the things which would need to be addressed: https://github.com/markqvist/LXMF/blob/390cac84e3863627542ed3c723ad5d9d74b5f305/LXMF/LXMRouter.py#L782