What is the best way to update the nodes locations from external source?

[martin20082018]

I have one question. From an external simulator items move to new locations (lat, long, alt) - in CORE I have the same items, but the location infos/changes come from the external simulator.

What is the best way to "feed in" this location updates into CORE?
See the image below.

Is there any code example somewhere for instance?
thanks!

[bharnden]

The best way would be over the gRPC API, which would have to be configured to serve the system externally.

/etc/core/core.conf

Update the line to use the address to listen on:
grpcaddress = localhost

Note that this does expose your system to have a service that can run arbitrary commands as root.

There is some documentation on using gRPC here; https://coreemu.github.io/core/grpc.html

And the call to move nodes in the current version, would be here and here.

[martin20082018]

Thank you for the answer. Meanwhile, I used the Python API for this approach, and it worked! :-)
BUT:
What I did for the test was this:
I created 1 WLAN node and add 3 mdr nodes, make links etc.
and at the end I called --> session.initiate()

But what if a new command is received and a new node has to be created and added to the session...
What is the correct way of doing this?

I had some problems to switch the session into CONFIGURATION_STATE and back...

Thank you for your support!!!

[bharnden]

You would just leave the state the same and can add nodes and links after instantiate. One issue that would stand out is that the links (interfaces) tied to a node can determine what happens for a service.

So if you modify a node by way of adding links during runtime and that node has a service that dynamically configures itself depending upon interface information, then you would need to restart those services.

[martin20082018]

Thank you! Works! :-)
Strange behavior when I try to remove a rj45 node - lets say CoreNode4 is connected to a rj45 node.
And when I try to remove a rj45 node after I removed "CoreNode4" --> I get in the terminal the message that the Node was removed but right after it is restored.... and in the SDT3D tool the Rj45 node don't disappear...
What can be the problem her ?
pseudo code:
...
testcore.Delete_Node(session, CoreNode4)
if rj45Node_var != None: # means that there is a rj45 node connected to the CoreNode4
.....testcore.Delete_Node(session, rj45node)

The other "normal" mdr nodes can be removed -- and disappear on the SDT3D tool...
Are the function call of deleting a node testcore.Delete_Node(session, anyNode) is not enough?

Thank you for your support!!!

[bharnden]

Not sure what you mean by right after it is restored, you would have to provide the actual output to try and help provide context

[martin20082018]

type=3 means that the respective node shall be shutdown
3 node will be removed. Node4 is also conneted to a rj45 node.
Strange is that today also all nodes except the WLAN node has been removed even I do not modified the code much - just sorted a little bit - but no change in the calling function.
see last INFO line below. Are the commands I use to remove the nodes are correct?

INFO:root:type==3
INFO:root:deleted node(CoreNode2)
INFO:root:DELETE Node=2
LOG: CoreReceiverThread got data: %X (size=%d) 60655 1
INFO:root:type==3
INFO:root:deleted node(CoreNode3)
INFO:root:DELETE Node=3
LOG: CoreReceiverThread got data: %X (size=%d) 60655 0
INFO:root:type==3
INFO:root:deleted node(CoreNode4)
INFO:root:DELETE Node=4
INFO:root:deleted node(enp0s9_4)
INFO:root:restoring rj45 state: enp0s9_4

so all nodes should be removed and shutdown
After pressing 'x':

session.delete_nodes()
logging.info("SESSION delete_nodes")

After pressing 'q':

logging.info("KEY q has pressed")
sock.close()
session.shutdown()
sys.exit()

xINFO:root:KEY q has pressed
INFO:root:session(1) state(EventTypes.RUNTIME_STATE) shutting down
INFO:root:changing session(1) to state SHUTDOWN_STATE
qINFO:root:LOG: HlaReceiverThread received event. Exiting
INFO:root:LOG: Main: about to set event
sock close
INFO:root:session(1) state(EventTypes.SHUTDOWN_STATE) already shutdown
INFO:root:shutting down all sessions
INFO:root:session(1) state(EventTypes.SHUTDOWN_STATE) already shutdown

Process finished with exit code 0                      

[bharnden]

I don't think I have enough context to really say what you are doing, as it seems you are doing your own special thing, which is outside of typical usage. So anything may and could matter.

[martin20082018]

Hi,
I think I use the normal Python API doing this job.
You mentioned IN one of your previous messages, that you would use gprc to use....
Meanwhile I implemented the "normal" API.

I am using 2 threads.

• One thread for receiving UDP packets, unpack the data and put a subset of the data in a queue
• and one thread for listening to the queue if there a entries to process.

If something is in the queue

• read the queue and run receptive commands
  • initiate/create a new node
  • update the node (lat,lon,alt)
  • cancel the node

See here some of the code snippets showing the part where nodes created , updated and canceled.

# main program:
...
testcore       = TestCore()
testnodeupdate = TestNodes()
wlan_node_l = []
DIS_ID: Dict[Any, Any] = {}
...
coreemu = CoreEmu({"controlnet": "176.16.0.0/24"})
session = coreemu.create_session()
session.sdt.initialize()
...

# start HlaReceiverThread and CoreReceiverThread
with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
    executor.submit(HlaReceiverThread, UDPsock, pipeline, eventflag, hla_lock)
    executor.submit(CoreReceiverThread, pipeline, eventflag, core_lock)

def CoreReceiverThread(queue_con, event, core_lock):

    print("enter CoreReceiverThread", flush=True)
    testcore.WLAN_Node_Init(session, refgeo, wlan_node_l)
    print("LOG: CoreReceiverThread wlan_node.id: %d" % (wlan_node_l[0].id), flush=True)

    while not event.is_set():  # or not queue.empty():

        if not queue_con.empty():
   
            data = queue_con.get()

            if data[2] == 1:  # create new communication node
                print("type==2", flush=True)
                lat = data[5]
                lon = data[6]
                alt = data[7]
                pos = (lat, lon, alt)
                DIS_ID[data[4]] = [None, None]
                testcore.Create_Node(session, DIS_ID, data[4], pos, wlan_node_l,ip_prefixes)
                len = node_list.__len__()
                initiCNT = initiCNT + 1
                if initiCNT == 3:
                    session.instantiate()
                    initiCNT = 0
                    subprocess.check_call("sdtcmd layer " + "CORE::Links,on",shell=True)
                stop = 1
            elif data[2] == 2:  # update location on specific node
                print("type==2", flush=True)
                lat = data[5]
                lon = data[6]
                alt = data[7]
                pos = (lat, lon, alt)
                testnodeupdate.test_node_update_HLA(session, DIS_ID[data[4]][0], pos)
                print("LOG: Node-Update-ID: %d DIS_ID: %d" % (DIS_ID[data[4]][0].id, data[4]), flush=True)
            elif data[2] == 3:  # cancel specific node
                logging.info("type==3")
                testcore.Delete_Node(session, DIS_ID[data[4]][0])
                logging.info("DELETE Node=%d" % DIS_ID[data[4]][0].id)
                if DIS_ID[data[4]][1] != None:
                    testcore.Delete_Node(session, DIS_ID[data[4]][1])
                    print("DELETE RJ45 Node=%d" % (DIS_ID[data[4]][1].id), flush=True)
            else:
                print("some type-error has happened!!!", flush=True)

    logging.info("LOG: CoreReceiverThread received event. Exiting")

The code simply uses the Python API to create, update and cancel the nodes.

My question is:
Does this sounds a possible way?
Or you definitely would propose the usage of the gprc.
--> The code for gprc seemed to me "only" different how the session more or less is generated. And no huge change in the create, update and cancel functions...
And here is the example code for creation, update and cancel functions (also mainly from your Python API)

    def Create_Node(self, session: Session, DIS_ID, idx, pos, wlan_node, ip_prefixes):

        # create nodes
        options = NodeOptions(model="mdr")
        logging.info("LOG: MT: create node")
        options.set_location(pos[0], pos[1], pos[2])
        node = session.add_node(CoreNode, options=options)
        session.services.add_services(node, node.type, ["SSH"])
        DIS_ID[idx][0] = node
        # *******************************************************
        # link nodes
        logging.info("LOG: MT: link nodes")
        iface_id = ip_prefixes.create_iface(node)
        logging.info("LOG: node.id: %d" % (node.id))
        logging.info("LOG: wlan_node.id: %d" % (wlan_node[0].id))
        session.add_link(node.id, wlan_node[0].id, iface1_data=iface_id)
        # *******************************************************
        if node.id == 4: 
            # ****** RJ45 *******
            options = NodeOptions(name="enp0s9_4")
            options.set_location(53.960087, 8.617760, 600)
            # ip generator
            ip_pref_rj45 = IpPrefixes(ip4_prefix="10.10.45.1/24")
            # create rj45 node
            rj45 = session.add_node(Rj45Node, options=options)
            DIS_ID[idx][1] = rj45
            # create interfaces
            interface = ip_pref_rj45.create_iface(node)
            rj45_interface = ip_pref_rj45.create_iface(node)
            # link nodes
            session.add_link(node.id, rj45.id, iface1_data=interface,iface2_data=rj45_interface)

    def Delete_Node(self, session: Session, node_l):
        # delete a single node
        session.delete_node(node_l.id)

Hope that this helps better to understand what I am doing.
The implementation works good; nodes get created and moves according to update events. Also the communication via the RJ45 node/interface o the outside world works inclusive the SSH connections to the internal nodes.
Please give me some advice whether I should better go for gprc or not in this case.
What is still missing in my code is, is the use of locks for the queue access in the 2 threads.

Thank you for your help!