changes to support a simpler start/stop session API

daemon/core/api/grpc/client.py

@@ -148,6 +148,31 @@ class CoreGrpcClient:
         self.stub = None
         self.channel = None
 
+    def start_session(self, session_id, nodes, links):
+        """
+        Start a session.
+
+        :param int session_id: id of session
+        :param list nodes: list of nodes to create
+        :param list links: list of links to create
+        :return:
+        """
+        request = core_pb2.StartSessionRequest(
+            session_id=session_id, nodes=nodes, links=links
+        )
+        return self.stub.StartSession(request)
+
+    def stop_session(self, session_id):
+        """
+        Stop a running session.
+
+        :param int session_id: id of session
+        :return: stop session response
+        :rtype: core_pb2.StopSessionResponse
+        """
+        request = core_pb2.StopSessionRequest(session_id=session_id)
+        return self.stub.StopSession(request)
+
     def create_session(self, session_id=None):
         """
         Create a session.

daemon/core/api/grpc/grpcutils.py

@@ -0,0 +1,55 @@
+import asyncio
+import logging
+import time
+
+from core.emulator.emudata import NodeOptions
+from core.emulator.enumerations import NodeTypes
+
+
+def add_node_data(node_proto):
+    _id = node_proto.id
+    _type = node_proto.type
+    if _type is None:
+        _type = NodeTypes.DEFAULT.value
+    _type = NodeTypes(_type)
+
+    options = NodeOptions(name=node_proto.name, model=node_proto.model)
+    options.icon = node_proto.icon
+    options.opaque = node_proto.opaque
+    options.image = node_proto.image
+    options.services = node_proto.services
+    if node_proto.server:
+        options.server = node_proto.server
+
+    position = node_proto.position
+    options.set_position(position.x, position.y)
+    options.set_location(position.lat, position.lon, position.alt)
+    return _type, _id, options
+
+
+async def async_add_node(session, node_proto):
+    _type, _id, options = add_node_data(node_proto)
+    session.add_node(_type=_type, _id=_id, options=options)
+
+
+async def create_nodes(loop, session, node_protos):
+    tasks = []
+    for node_proto in node_protos:
+        task = loop.create_task(async_add_node(session, node_proto))
+        tasks.append(task)
+
+    start = time.monotonic()
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+    total = time.monotonic() - start
+
+    logging.info(f"created nodes time: {total}")
+    return results
+
+
+def sync_create_nodes(session, node_protos):
+    start = time.monotonic()
+    for node_proto in node_protos:
+        _type, _id, options = add_node_data(node_proto)
+        session.add_node(_type=_type, _id=_id, options=options)
+    total = time.monotonic() - start
+    logging.info(f"created nodes time: {total}")

daemon/core/api/grpc/server.py

@@ -9,7 +9,7 @@ from queue import Empty, Queue
 
 import grpc
 
-from core.api.grpc import core_pb2, core_pb2_grpc
+from core.api.grpc import core_pb2, core_pb2_grpc, grpcutils
 from core.emane.nodes import EmaneNet
 from core.emulator.data import (
     ConfigData,
@@ -260,6 +260,53 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
         except CoreError:
             context.abort(grpc.StatusCode.NOT_FOUND, f"node {node_id} not found")
 
+    def StartSession(self, request, context):
+        """
+        Start a session.
+
+        :param core.api.grpc.core_pb2.StartSessionRequest request: start session request
+        :param context: grcp context
+        :return: start session response
+        :rtype: core.api.grpc.core_pb2.StartSessionResponse
+        """
+        logging.debug("start session: %s", request)
+        session = self.get_session(request.session_id, context)
+
+        # clear previous state and setup for creation
+        session.clear()
+        session.set_state(EventTypes.CONFIGURATION_STATE)
+        if not os.path.exists(session.session_dir):
+            os.mkdir(session.session_dir)
+
+        # create nodes
+        # loop = asyncio.new_event_loop()
+        # asyncio.set_event_loop(loop)
+        # results = loop.run_until_complete(
+        #     grpcutils.create_nodes(loop, session, request.nodes)
+        # )
+        grpcutils.sync_create_nodes(session, request.nodes)
+
+        # set to instantiation and start
+        session.set_state(EventTypes.INSTANTIATION_STATE)
+        session.instantiate()
+
+        return core_pb2.StartSessionResponse(result=True)
+
+    def StopSession(self, request, context):
+        """
+        Stop a running session.
+
+        :param core.api.grpc.core_pb2.StopSessionRequest request: stop session request
+        :param context: grcp context
+        :return: stop session response
+        :rtype: core.api.grpc.core_pb2.StopSessionResponse
+        """
+        logging.debug("stop session: %s", request)
+        session = self.coreemu.create_session(request.session_id)
+        session.set_state(EventTypes.DATACOLLECT_STATE)
+        session.clear()
+        return core_pb2.StopSessionResponse(result=True)
+
     def CreateSession(self, request, context):
         """
         Create a session