swarmit 0.3.0__py3-none-any.whl → 0.4.5__py3-none-any.whl

testbed/swarmit/adapter.py

@@ -1,19 +1,27 @@
 """Module containing classes for interfacing with the DotBot gateway."""
 
-import base64
+import time
 from abc import ABC, abstractmethod
 
-import paho.mqtt.client as mqtt
-from dotbot.hdlc import HDLCHandler, HDLCState, hdlc_encode
-from dotbot.protocol import PROTOCOL_VERSION
-from dotbot.serial_interface import SerialInterface
+from dotbot.protocol import (
+    Packet,
+    Payload,
+    ProtocolPayloadParserException,
+)
+from marilib.communication_adapter import MQTTAdapter as MarilibMQTTAdapter
+from marilib.communication_adapter import SerialAdapter as MarilibSerialAdapter
+from marilib.mari_protocol import Frame as MariFrame
+from marilib.marilib_cloud import MarilibCloud
+from marilib.marilib_edge import MarilibEdge
+from marilib.model import EdgeEvent, MariNode
+from rich import print
 
 
 class GatewayAdapterBase(ABC):
     """Base class for interface adapters."""
 
     @abstractmethod
-    def init(self, on_data_received: callable):
+    def init(self, on_frame_received: callable):
         """Initialize the interface."""
 
     @abstractmethod
@@ -21,74 +29,114 @@ class GatewayAdapterBase(ABC):
         """Close the interface."""
 
     @abstractmethod
-    def send_data(self, data):
-        """Send data to the interface."""
-
-
-class SerialAdapter(GatewayAdapterBase):
-    """Class used to interface with the serial port."""
-
-    def __init__(self, port, baudrate):
-        self.port = port
-        self.baudrate = baudrate
-        self.hdlc_handler = HDLCHandler()
-
-    def on_byte_received(self, byte):
-        self.hdlc_handler.handle_byte(byte)
-        if self.hdlc_handler.state == HDLCState.READY:
-            self.on_data_received(self.hdlc_handler.payload)
-
-    def init(self, on_data_received: callable):
-        self.serial = SerialInterface(
-            self.port, self.baudrate, self.on_byte_received
+    def send_payload(self, destination: int, payload: Payload):
+        """Send payload to the interface."""
+
+
+class MarilibEdgeAdapter(GatewayAdapterBase):
+    """Class used to interface with Marilib."""
+
+    def on_event(self, event: EdgeEvent, event_data: MariNode | MariFrame):
+        if event == EdgeEvent.NODE_JOINED:
+            if self.verbose:
+                print("[green]Node joined:[/]", event_data)
+        elif event == EdgeEvent.NODE_LEFT:
+            if self.verbose:
+                print("[orange]Node left:[/]", event_data)
+        elif event == EdgeEvent.NODE_DATA:
+            try:
+                packet = Packet.from_bytes(event_data.payload)
+            except (ValueError, ProtocolPayloadParserException) as exc:
+                print(f"[red]Error parsing packet: {exc}[/]")
+                return
+            if not hasattr(self, "on_frame_received"):
+                return
+            self.on_frame_received(event_data.header, packet)
+
+    def __init__(self, port: str, baudrate: int, verbose: bool = False):
+        self.verbose = verbose
+        self.mari = MarilibEdge(
+            self.on_event, MarilibSerialAdapter(port, baudrate)
         )
-        self.on_data_received = on_data_received
-        # Just write a single byte to fake a DotBot gateway handshake
-        self.serial.write(int(PROTOCOL_VERSION).to_bytes(length=1))
 
-    def close(self):
-        self.serial.stop()
+    def _busy_wait(self, timeout: int):
+        """Wait for the condition to be met."""
+        while timeout > 0:
+            self.mari.update()
+            timeout -= 0.1
+            time.sleep(0.1)
 
-    def send_data(self, data):
-        self.serial.write(hdlc_encode(data))
+    def init(self, on_frame_received: callable):
+        self.on_frame_received = on_frame_received
+        if self.verbose:
+            self._busy_wait(3)
+            print("[yellow]Mari nodes available:[/]")
+            print(self.mari.nodes)
 
+    def close(self):
+        pass
 
-class MQTTAdapter(GatewayAdapterBase):
-    """Class used to interface with MQTT."""
-
-    def __init__(self, host, port):
-        self.host = host
-        self.port = port
-        self.client = None
+    def send_payload(self, destination: int, payload: Payload):
+        self.mari.send_frame(
+            dst=destination,
+            payload=Packet.from_payload(payload).to_bytes(),
+        )
 
-    def on_message(self, client, userdata, message):
-        self.on_data_received(base64.b64decode(message.payload))
 
-    def on_log(self, client, userdata, paho_log_level, messages):
-        print(messages)
+class MarilibCloudAdapter(GatewayAdapterBase):
+    """Class used to interface with Marilib."""
+
+    def on_event(self, event: EdgeEvent, event_data: MariNode | MariFrame):
+        if event == EdgeEvent.NODE_JOINED:
+            if self.verbose:
+                print("[green]Node joined:[/]", event_data)
+        elif event == EdgeEvent.NODE_LEFT:
+            if self.verbose:
+                print("[orange]Node left:[/]", event_data)
+        elif event == EdgeEvent.NODE_DATA:
+            try:
+                packet = Packet.from_bytes(event_data.payload)
+            except (ValueError, ProtocolPayloadParserException) as exc:
+                print(f"[red]Error parsing packet: {exc}[/]")
+                return
+            if not hasattr(self, "on_frame_received"):
+                return
+            self.on_frame_received(event_data.header, packet)
+
+    def __init__(
+        self,
+        host: str,
+        port: int,
+        use_tls: bool,
+        network_id: int,
+        verbose: bool = False,
+    ):
+        self.verbose = verbose
+        self.mari = MarilibCloud(
+            self.on_event,
+            MarilibMQTTAdapter(host, port, use_tls=use_tls, is_edge=False),
+            network_id,
+        )
 
-    def on_connect(self, client, userdata, flags, reason_code, properties):
-        self.client.subscribe("/pydotbot/edge_to_controller")
+    def _busy_wait(self, timeout):
+        """Wait for the condition to be met."""
+        while timeout > 0:
+            self.mari.update()
+            timeout -= 0.1
+            time.sleep(0.1)
 
-    def init(self, on_data_received: callable):
-        self.on_data_received = on_data_received
-        self.client = mqtt.Client(
-            mqtt.CallbackAPIVersion.VERSION2,
-            protocol=mqtt.MQTTProtocolVersion.MQTTv5,
-        )
-        self.client.tls_set_context(context=None)
-        # self.client.on_log = self.on_log
-        self.client.on_connect = self.on_connect
-        self.client.on_message = self.on_message
-        self.client.connect(self.host, self.port, 60)
-        self.client.loop_start()
+    def init(self, on_frame_received: callable):
+        self.on_frame_received = on_frame_received
+        if self.verbose:
+            self._busy_wait(3)
+            print("[yellow]Mari nodes available:[/]")
+            print(self.mari.nodes)
 
     def close(self):
-        self.client.disconnect()
-        self.client.loop_stop()
+        pass
 
-    def send_data(self, data):
-        self.client.publish(
-            "/pydotbot/controller_to_edge",
-            base64.b64encode(data).decode(),
+    def send_payload(self, destination: int, payload: Payload):
+        self.mari.send_frame(
+            dst=destination,
+            payload=Packet.from_payload(payload).to_bytes(),
         )