LXMF Basic Question

[HarlekinSimplex]

Hi all,

actually I'm struggling with getting LXMF to work.

Here a code snippet that seems to work except the message sent is never delivered.

    lxm_router = LXMF.LXMRouter(storagepath=lxm_storage)
    lxm_router.register_delivery_callback(lxmf_delivery_callback)

    identity_a = RNS.Identity()
    identity_b = RNS.Identity()

    source = RNS.Destination(
        identity_a,
        RNS.Destination.OUT,
        RNS.Destination.SINGLE,
        "nexus",
        "cockpit"
    )
    RNS.log("source full address: " + str(source))
    RNS.log("source address (hash): " + RNS.prettyhexrep(source.hash))
    source.announce()

    destination = RNS.Destination(
        identity_b,
        RNS.Destination.IN,
        RNS.Destination.SINGLE,
        "nexus",
        "cockpit"
    )
    RNS.log("destination full address: " + str(destination))
    RNS.log("destination address (hash): " + RNS.prettyhexrep(destination.hash))
    destination.announce()

    lxm_message = LXMF.LXMessage(destination, source, "Content String A->B", "Title String")
    lxm_router.handle_outbound(lxm_message)

    while True:
        time.sleep(5)
        destination.announce()
        source.announce()

within the level 7 log the following appears endlessly:

[2022-04-10 12:50:17] [Debug] Starting outbound processing for <LXMessage c012697f557f7301c2f1e91e80326b267e6504c569ad208358a050f58d709987> to <d43b604535c1eb0ea810>

So it seem everything is well.
The LXMF Router is up.
Both destinations are set up.
The message was ingested and bound to transportation.

How ever, the delivery callback gets never called.
Skimming through the code of LXMF and Nodmadnet did not help to find the solution.
It looks like the router is doing a lot in the backround but somehow nothing seems to reach the target.

I tried a more coplex example sending a message accross a single hop.
With that I saw anounces beeing sent, validated and stored for the target.
So all required keys, paths and tunnel seem to be there as expected.
How ever, again all ends with continuously logging that the outbound processing is started but the delivery callback seems never be called here too.

I guess there is something essential missing in my understanding, but what?

Any help would be appreciated.
Maybe one can provide a working simple example that sends a oportunistic "Hello World" LXMF message from A to B with printing out what has been sent when it arrives B?

Cheers
Stephan

[HarlekinSimplex]

Some insights I gained.
Using LXMF.LXMessage() without specifing a delivery method seems to be pointless.
In the LXMF code do so simply leads to the effect I described above. There is obviously no usefull default applied.

To send a message something like this is required:

        lxm_message = LXMF.LXMessage(
            to_destination,
            destination_hash=to_destination_hash,
            source=from_destination,
            content=message_text,
            title=message_title,
            desired_method=LXMF.LXMessage.DIRECT
        )

DIRECT instructs LXMF to use Link to transport the message. With that larger messages are possible as with OPORTUNISTIC.

The both destination objects are required.
Especially the to_destination Object.
This is simply because LXMessage needs the identity assigned to the destination object to fetch the public keys to encrypt the message.
But this is not enough. The destination hash of a destination is unique and created anew everytime a destination instance is created. So just adding the Identity you got with the announce or may have shared somehow to the destination object would result into a different destination!
Thats the reason why it is necessary to provide a initialized destination object with the correct identity set AND the destination hash of the destination.

It would be very helpful if we could create a RNS.Destination object from a given Identity and Destination Hash and/or the message function would accept hash/id OR a fully set up destination object for both destinations.

With that snippet the log came to live with way more information about the transport beeing processed then before.

How ever, the delivery callback still gets called only if assigned to a message and not to the router.
With that it just Indicates that a message was devlivered to the destination.
By now I did not find a way how I can make LXMF notice the destination that a message as arrived.
... to be continued.

Question:
Is there any documentation of the LXMF objects and methods available?
I didn't find such by now.

Cheers
Stephan

[markqvist]

I am going to just paste the answer here, that I wrote as a reply to your issue #4 on LXMF, since it is the most clear answer to this :)

[markqvist]

This is working as intended ;) Until globally routed multicast is implemented in Reticulum, the only way to send LXMs to GROUP destination is via propagation nodes:

lxmessage = LXMF.LXMessage(
    destination=destination_to1,
    source=destination_from,
    content=message_text,
    title=message_title,
    desired_method=LXMF.LXMessage.PROPAGATED
)

lxrouter = LXMF.LXMRouter(storagepath=LXMF_STORAGE_PATH)
lxrouter.set_outbound_propagation_node(bytes.fromhex("3308bc1aa72e9761fca2"))

Produces the following result:

[2022-04-13 11:57:02] [Verbose] Identity keys created for <ebf66a2830d1a154f142>
[2022-04-13 11:57:02] [Debug] Starting outbound processing for <LXMessage 5117036bf5cc31dadded4ab40ea31390c4c74f3da6eb900eb7053d11926c9c60> to <df98e7ddf0e79124a64a>
[2022-04-13 11:57:02] [Debug] Attempting propagated delivery for <LXMessage 5117036bf5cc31dadded4ab40ea31390c4c74f3da6eb900eb7053d11926c9c60> to <df98e7ddf0e79124a64a>
[2022-04-13 11:57:02] [Debug] No path known for propagation attempt 1 to <3308bc1aa72e9761fca2>. Requesting path...
[2022-04-13 11:57:02] [Debug] Validating announce from <ea75f96ea04e159c7ba2>
[2022-04-13 11:57:02] [Debug] Stored valid announce from <ea75f96ea04e159c7ba2>
[2022-04-13 11:57:02] [Verbose] Path to <ea75f96ea04e159c7ba2> is now 0 hops away via <8d82eb8cc5d4de1a701c> on LocalInterface[37428]
[2022-04-13 11:57:03] [Debug] Validating announce from <3308bc1aa72e9761fca2>
[2022-04-13 11:57:03] [Debug] Stored valid announce from <3308bc1aa72e9761fca2>
[2022-04-13 11:57:03] [Verbose] Path to <3308bc1aa72e9761fca2> is now 2 hops away via <8d82eb8cc5d4de1a701c> on LocalInterface[37428]
[2022-04-13 11:57:06] [Debug] Validating announce from <3dc65a05105c7d7dab35>
[2022-04-13 11:57:06] [Debug] Stored valid announce from <3dc65a05105c7d7dab35>
[2022-04-13 11:57:06] [Verbose] Path to <3dc65a05105c7d7dab35> is now 3 hops away via <8d82eb8cc5d4de1a701c> on LocalInterface[37428]
[2022-04-13 11:57:07] [Debug] Starting outbound processing for <LXMessage 5117036bf5cc31dadded4ab40ea31390c4c74f3da6eb900eb7053d11926c9c60> to <df98e7ddf0e79124a64a>
[2022-04-13 11:57:07] [Debug] Attempting propagated delivery for <LXMessage 5117036bf5cc31dadded4ab40ea31390c4c74f3da6eb900eb7053d11926c9c60> to <df98e7ddf0e79124a64a>
[2022-04-13 11:57:07] [Debug] Establishing link to <3308bc1aa72e9761fca2> for propagation attempt 2 to <df98e7ddf0e79124a64a>
[2022-04-13 11:57:07] [Debug] Registering link <559838619cbba5a6e793>
[2022-04-13 11:57:07] [Debug] Link request <559838619cbba5a6e793> sent to <lxmf.propagation.364d6282ccce0511dd40/3308bc1aa72e9761fca2>
[2022-04-13 11:57:07] [Debug] Activating link <559838619cbba5a6e793>
[2022-04-13 11:57:07] [Verbose] Link <559838619cbba5a6e793> established with <lxmf.propagation.364d6282ccce0511dd40/3308bc1aa72e9761fca2>, RTT is 0.15389752388000488
[2022-04-13 11:57:07] [Debug] Starting outbound processing for <LXMessage 5117036bf5cc31dadded4ab40ea31390c4c74f3da6eb900eb7053d11926c9c60> to <df98e7ddf0e79124a64a>
[2022-04-13 11:57:07] [Debug] Attempting propagated delivery for <LXMessage 5117036bf5cc31dadded4ab40ea31390c4c74f3da6eb900eb7053d11926c9c60> to <df98e7ddf0e79124a64a>
[2022-04-13 11:57:07] [Debug] Starting propagation transfer of <LXMessage 5117036bf5cc31dadded4ab40ea31390c4c74f3da6eb900eb7053d11926c9c60> to <df98e7ddf0e79124a64a> via <3308bc1aa72e9761fca2>
[2022-04-13 11:57:07] [Debug] Received propagation success notification for <LXMessage 5117036bf5cc31dadded4ab40ea31390c4c74f3da6eb900eb7053d11926c9c60>
[2022-04-13 11:57:12] [Debug] Propagation has occurred for <LXMessage 5117036bf5cc31dadded4ab40ea31390c4c74f3da6eb900eb7053d11926c9c60>, removing from outbound queue

This is all more or less impossible to figure out without the LXMF documentation being published, so I'm impressed you made it that far ;)

In general there is a lot of things related to group messaging that is not completely ready yet, and that is why you are running into all those problems and the other errors you reported.

Give it a month or so, and it will be there, with a well documented API. Until the it's gonna be a bit rough sailing, and things might very well change API wise during that time ;)

[markqvist]

TLDR: In general there is a lot of things related to group messaging that is not completely ready yet. Give it a month or so, and it will be there, with a well documented API. Until the it's gonna be a bit rough sailing, and things might very well change API wise during that time.

[HarlekinSimplex]

Just to complete the answer how to receive LXMF messages:

To get a delivery receipt that the message has been successfully delivered one needs to register a delivery callback with the message sent like this:

        lxm_message = LXMF.LXMessage(
            to_destination,
            destination_hash=to_destination_hash,
            source=from_destination,
            content=message_text,
            title=message_title,
            desired_method=LXMF.LXMessage.DIRECT
        )
        RNS.log(
            "LXM handle outbound for message sent to " + RNS.prettyhexrep(to_destination_hash) +
            " from " + RNS.prettyhexrep(self.from_destination.hash)
        )
        lxm_message.register_delivery_callback(lxmf_delivery_callback)
        lxm_router.handle_outbound(lxm_message)

The registered handler may look like this:

    def lxmf_delivery_callback(message):
        time_string = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(message.timestamp))
        signature_string = "Signature is invalid, reason undetermined"
        if message.signature_validated:
            signature_string = "Validated"
        else:
            if message.unverified_reason == LXMF.LXMessage.SIGNATURE_INVALID:
                signature_string = "Invalid signature"
            if message.unverified_reason == LXMF.LXMessage.SOURCE_UNKNOWN:
                signature_string = "Cannot verify, source is unknown"
        # Log LXM message received event
        RNS.log("Delivered LXMF message " + time_string + " " + signature_string)
        RNS.log("-       Title: " + message.title.decode('utf-8'))
        RNS.log("-     Content: " + message.content.decode('utf-8'))
        RNS.log("-      Source: " + RNS.prettyhexrep(message.source_hash))
        RNS.log("- Destination: " + RNS.prettyhexrep(message.destination_hash))

To get a Callback in case a message is delivered to a destination one need to register a proper Link handler to the destination like this:

    # Register callback to process incoming links
    from_destination.set_link_established_callback(client_connected)

That link handler then (at least) needs to set a appropriate resource strategy and a packet handler to digest the received resource.
For more information on resource and link handling see the Reticulum API documentation.
Here a example of a minimal link and a packet handler to produce a log output like with the delivery receipt:

    def client_connected(link):
        link.set_resource_strategy(RNS.Link.ACCEPT_ALL)
        link.set_packet_callback(packet_received)

    def packet_received(lxmf_bytes, packet):
        # Unpack message received
        message = LXMF.LXMessage.unpack_from_bytes(lxmf_bytes)
        # Log Message
        time_string = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(message.timestamp))
        signature_string = "Signature is invalid, reason undetermined"
        if message.signature_validated:
            signature_string = "Validated"
        else:
            if message.unverified_reason == LXMF.LXMessage.SIGNATURE_INVALID:
                signature_string = "Invalid signature"
            if message.unverified_reason == LXMF.LXMessage.SOURCE_UNKNOWN:
                signature_string = "Cannot verify, source is unknown"
        # Log LXM message received event
        RNS.log("Received LXMF message " + time_string + " " + signature_string)
        RNS.log("-       Title: " + message.title.decode('utf-8'))
        RNS.log("-     Content: " + message.content.decode('utf-8'))
        RNS.log("-      Source: " + RNS.prettyhexrep(message.source_hash))
        RNS.log("- Destination: " + RNS.prettyhexrep(message.destination_hash))

This works nicely if the message does not exceed the capacity of a single RNS Packet.
If it is larger (what is the main purpose to go down this route in the first place) LXMF provides a file ressource that is stored at the local storage path that has been provided with the instantiation of the LXMRouter class.

To retrieve the message content you need to read and process that file.
How that is done I'll share as soon as I have it running at my side.
...to be continued.

[markqvist]

Thanks for taking the time to write up the information. To receive the LXMF messages, you don't actuallly have to read the stored files, just set the delivery callback for your instantiated message router using register_delivery_callback(f), and your apps callback will get called in realtime every time an LXMF message is received :)

Also, I should probably say that anyone wanting to actually use the LXMF API without significant amounts of hairpulling shold probably wait until I add the actual API documentation (which will happen within the next month or so). Stephan here is just crazy enough to have gone and figured it out more or less without documentation ;)

[HarlekinSimplex]

Yeaaah Crazy I'am :-)

To set the callback this way I'll definitely try - eventually.
The question here is, What LXMF message would be passed with that delivery call to the app?
A single packet sized message or (if it was that big) the full amount of data of all packets the message was split into?

---

How ever, I have now all pieces figured out to handle LXMF messages over the network for my application.

• Getting receipts for the delivery
• Receiving Single Paket sized messages
• Receiving Multi Package message

Further I put all that stuff into a Class that can be used as a template for other like LXM applications.

Here is how the class can be put to work:

    APP_NAME = "nexus"
    NEXUS_SERVER_ASPECT = "server"
    LXMF_STORAGE_PATH = os.path.expanduser("~") + "/.nexus/lxmf"
    NEXUS_SERVER_LONGPOLL = 5 # 5 secondes should be used for test purpose only. Should be 4*60*60 or like for production
    NEXUS_LXM_SOCKET = None  # type: NexusLXMSocket

    # Create LXMF router socket with this server as source endpoint
    NEXUS_LXM_SOCKET = NexusLXMSocket()

    # Start long poll to announce server regularly
    NexusLXMSocket.long_poll()

This example creates an LXMF server endpoint for SINGLE type messages.
By calling the long_poll() methode this endpoint starts announcing itself each 5 seconds.
Now setup another RNS node and configure that node to join the RNS network of the first node.
Instantiate the LXMSocket on that node as well and trigger the auto announce too.

Now the magic begins.

As soon as one of those two nodes receives the announcement of the other node, it sends two LXMessages to that announced node.
One short enough that it fits into one RNS Paket, and the other one large enough that it requires LXMF to spilt it into at least two packages.

If you set the log level at the reticulum configs to 7 (extrem) you can analyse in detail what is going on at both sides.
At the end the log should contain delivery receipts as well as receive notifications of all messages send by both nodes.

Here comes the class...
It was pulled out of the real application, so some globals may be missing and the imports may be wrong or incomplete as well.
But I guess if you went that far, you'll be able to manage that.
And yes - For a real application you may change the announce handler according your needs.
Guess sending such double echo message ping pongs may not be that usefull beyond testting....
:-)

Hope that this wall of text spares every friendly reader the crazyness I'm so used to apply for years already while figuring out how genious software packages are working that are so brand new and cutting edge that no exhaustive documentation is available yet.
If you can wait for that to appear - wait.
If you can't wait take this example as a starting point.

Have fun.
And don't hesitate .... as usual.

import os
import signal
import threading
import sys
import LXMF
import RNS
import requests
import time
import RNS.vendor.umsgpack as umsgpack

##########################################################################################
# Nexus LXM router socket for LXMF message handling
#
class NexusLXMSocket:
    def __init__(self, socket_identity=None, storage_path=None, app_name=APP_NAME, server_aspect=NEXUS_SERVER_ASPECT):

        # Initialize members
        self.app_name = app_name
        self.server_aspect = server_aspect

        # If storage path was not set use default storage path
        self.storage_path = storage_path
        if self.storage_path is None:
            self.storage_path = LXMF_STORAGE_PATH
        # Check and create storage path if necessary
        if not os.path.isdir(self.storage_path):
            # Create storage path
            os.makedirs(self.storage_path)
            # Log that storage directory was created
            RNS.log("LXM Storage path was created")
        # Log storage path
        RNS.log("LXM Socket storage path is " + self.storage_path)

        # If identity was not given create a new for this lxm socket
        self.socket_identity = socket_identity
        if self.socket_identity is None:
            self.socket_identity = RNS.Identity()
        # Log that storage directory was created
        RNS.log("LXM Socket identity is " + str(self.socket_identity))

        # Initialize from destination to be used when sending nexus messages to other nexus servers
        self.socket_destination = RNS.Destination(
            self.socket_identity,
            RNS.Destination.IN,
            RNS.Destination.SINGLE,
            self.app_name,
            self.server_aspect
        )
        # Set proof strategy to PROVE_ALL
        self.socket_destination.set_proof_strategy(RNS.Destination.PROVE_ALL)

        # Log the crated lxm destination
        RNS.log("LXM Nexus Server from destination is " + str(self.socket_destination))
        RNS.log("LXM Nexus Server hash is " + RNS.prettyhexrep(self.destination_hash()))

        # Initialize lxm router
        self.lxm_router = LXMF.LXMRouter(
            identity=self.socket_identity,
            storagepath=self.storage_path
        )
        # Log updated server role
        RNS.log("LXM Router initialized with identity " + str(self.socket_identity))

        # Register callback to process incoming links
        self.socket_destination.set_link_established_callback(NexusLXMSocket.client_connected)
        # Log callback for incoming link registered
        RNS.log("LXM Link established callback registered")

        # Create a handler to process all incoming announcements with the aspect of this nexus server
        announce_handler = NexusLXMAnnounceHandler(aspect_filter=app_name + '.' + server_aspect)
        # Log announce filter
        RNS.log("LXM AnnounceHandler listens to " + app_name + '.' + server_aspect)
        # Register the handler with the reticulum transport layer
        RNS.Transport.register_announce_handler(announce_handler)

        # Flush pending log
        sys.stdout.flush()

    def destination_hash(self):
        return self.socket_destination.hash

    def send_lxm_hello(self, destination_hash, announced_identity):
        # Send two test messages to announced nexus server to test LXMF message processing
        # One single packet message
        # One multi packet message

        # Send single packet 'Hello World' message
        title = 'Hello Nexus Server'
        content = 'Hello World (Single Packet) - Time: ' + time.ctime(time.time())
        self.send_message(title, content, destination_hash, announced_identity)

        # Send Multi Packet Hello World message
        title = 'Hello Nexus Server'
        content = 'Hello World (Multi Packet) - Time: ' + time.ctime(time.time()) + \
                  '012345678901234567890123456789012345678901234567890' + \
                  '012345678901234567890123456789012345678901234567890' + \
                  '012345678901234567890123456789012345678901234567890' + \
                  '012345678901234567890123456789012345678901234567890' + \
                  '012345678901234567890123456789012345678901234567890'
        self.send_message(title, content, destination_hash, announced_identity)

    def send_message(self, title, content, destination_hash, identity):
        # Create destination
        to_destination = RNS.Destination(
            identity,
            RNS.Destination.OUT,
            RNS.Destination.SINGLE,
            self.app_name,
            self.server_aspect
        )
        # Create lxmessage and handle outbound to the target Nexus server with the lxm router
        lxm_message = LXMF.LXMessage(
            to_destination,
            destination_hash=destination_hash,
            source=self.socket_destination,
            content=content,
            title=title,
            desired_method=LXMF.LXMessage.DIRECT
        )

        # Register message handler
        # This is the good case - message is processed successfully
        lxm_message.register_delivery_callback(NexusLXMSocket.lxmf_delivery_callback)
        # Log delivery failure
        lxm_message.register_failed_callback(NexusLXMSocket.lxmf_delivery_callback)

        # Transfer handling of the message to LXMF
        RNS.log(
            "LXM handle outbound for message sent to " + RNS.prettyhexrep(destination_hash) +
            " from " + RNS.prettyhexrep(self.socket_destination.hash)
        )
        self.lxm_router.handle_outbound(lxm_message)

    ##########################################################################################
    # Announce the server to the reticulum network
    #
    # Calling this function will start a timer that will call this function again after the
    # specified re-announce period.
    #
    @staticmethod
    def announce():
        # Announce this server to the network
        NEXUS_LXM_SOCKET.socket_destination.announce()
        )
        # Log announcement / long poll announcement
        RNS.log(
            # Log entry does not use bytes but a string representation
            "LXM Nexus Server " + RNS.prettyhexrep(NEXUS_LXM_SOCKET.destination_hash()) + " announced"
        )

    @staticmethod
    def client_connected(link):
        link.set_resource_strategy(RNS.Link.ACCEPT_ALL)
        RNS.log("LXM Link Resource strategy set to ACCEPT_ALL")
        link.set_resource_concluded_callback(NexusLXMSocket.resource_concluded)
        RNS.log("LXM Resource concluded callback set")
        link.set_packet_callback(NexusLXMSocket.packet_received)
        RNS.log("LXM Packet callback set")

    @staticmethod
    def client_disconnect(link):
        RNS.log("LXM Client disconnected " + str(link))
        if link.teardown_reason == RNS.Link.TIMEOUT:
            RNS.log("The link timed out, exiting now")
        elif link.teardown_reason == RNS.Link.DESTINATION_CLOSED:
            RNS.log("The link was closed by the server, exiting now")
        else:
            RNS.log("Link closed")

    @staticmethod
    def packet_received(lxmf_bytes, packet):
        RNS.log("LXM single packet delivered " + str(packet))
        # Process received lxmf bytes into a lxmessage
        NexusLXMSocket.process_lxmf_message_bytes(lxmf_bytes)

    @staticmethod
    def resource_concluded(resource):
        RNS.log("LXM Resource data transfer (multi packet) delivered " + str(resource.file))
        # Check if transfer is completed
        # otherwise log that it is not
        if resource.status == RNS.Resource.COMPLETE:
            # Read collected parts from the read file handle that came with the resource
            lxmf_bytes = resource.data.read()
            # Process received lxmf bytes into a lxmessage
            NexusLXMSocket.process_lxmf_message_bytes(lxmf_bytes)
        else:
            RNS.log("Received LXMF resource message is not complete")

    @staticmethod
    def process_lxmf_message_bytes(lxmf_bytes):
        try:
            # Assemble message object from read bytes
            message = LXMF.LXMessage.unpack_from_bytes(lxmf_bytes)
        except Exception as e:
            RNS.log("Could not assemble LXMF message from received data", RNS.LOG_NOTICE)
            RNS.log("The contained exception was: " + str(e), RNS.LOG_DEBUG)
            return

        # Log message as delivery receipt
        NexusLXMSocket.log_message(message, "LXMF Message received")

    @staticmethod
    def lxmf_delivery_callback(message):
        # Log message as delivery receipt
        NexusLXMSocket.log_message(message, "LXMF Delivery receipt")

    @staticmethod
    def log_message(message, message_tag="LXMF Message log"):
        # Log Message
        # Create time stamp for logging
        time_string = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(message.timestamp))
        # Check and log signature status
        if message.signature_validated:
            signature_string = "Validated"
        else:
            if message.unverified_reason == LXMF.LXMessage.SIGNATURE_INVALID:
                signature_string = "Invalid signature"
            elif message.unverified_reason == LXMF.LXMessage.SOURCE_UNKNOWN:
                signature_string = "Cannot verify, source is unknown"
            else:
                signature_string = "Signature is invalid, reason undetermined"
        # Log LXM message received event
        title = message.title.decode('utf-8')
        content = message.content.decode('utf-8')
        RNS.log(message_tag + " - " + time_string)
        RNS.log("-       Title: " + title)
        RNS.log("-     Content: " + content)
        RNS.log("-        Size: " + str(len(content)) + " bytes")
        RNS.log("-      Source: " + RNS.prettyhexrep(message.source_hash))
        RNS.log("- Destination: " + RNS.prettyhexrep(message.destination_hash))
        RNS.log("-   Signature: " + signature_string)

    @staticmethod
    def long_poll():
        # Announce this server to the network
        # All other nexus server with the same aspect will register this server as a distribution target
        NEXUS_LXM_SOCKET.announce()

        # Start timer to re announce this server in due time as specified
        t = threading.Timer(NEXUS_SERVER_LONGPOLL, NEXUS_LXM_SOCKET.long_poll)
        # Start as daemon so it terminates with main thread
        t.daemon = True
        t.start()


##########################################################################################
# Reticulum handler class to process received announces
#
# This handler will be called as soon as an announcement of another nexus server was received.
#
class NexusLXMAnnounceHandler:
    global NEXUS_SERVER_ROLE
    global NEXUS_LXM_SOCKET

    # The initialisation method takes the optional
    # aspect_filter argument. If aspect_filter is set to
    # None, all announces will be passed to the instance.
    # If only some announces are wanted, it can be set to
    # an aspect string.
    def __init__(self, aspect_filter=None):
        self.aspect_filter = aspect_filter

    # This method will be called by Reticulums Transport
    # system when an announcement arrives that matches the
    # configured aspect filter. Filters must be specific,
    # and cannot use wildcards.
    @staticmethod
    def received_announce(destination_hash, announced_identity, app_data):

        # Log that we received an announcement matching our aspect filter criteria
        RNS.log(
            "Received an announce from " +
            RNS.prettyhexrep(destination_hash)
        )

        # Say Hello via LXM router
        RNS.log(
            "Send Hello to lxm messaging destination " + RNS.prettyhexrep(destination_hash)
        )
        NEXUS_LXM_SOCKET.send_lxm_hello(destination_hash, announced_identity)

    # Flush pending log
    sys.stdout.flush()