add NetworkCANPort resource and export

Add an exporter part for the remotely accessible CAN. As discussed, the
cannelloni is used as the underlying tunnel.

According to the cannelloni documentation, it should be used only in
environments where packet loss is tolerable. There is no guarantee that
CAN frames will reach their destination at all and/or in the right
order.

XXX: The permission handling needs to be fixed, as the code requires
running under a privileged user.

Signed-off-by: Tomas Novotny <tomas@novotny.cz>

Author: stoupa-cz

labgrid/remote/exporter.py

@@ -23,6 +23,7 @@
 from .common import ResourceEntry, queue_as_aiter
 from .generated import labgrid_coordinator_pb2, labgrid_coordinator_pb2_grpc
 from ..util import get_free_port, labgrid_version
+from ..util.helper import processwrapper
 
 
 exports: Dict[str, Type[ResourceEntry]] = {}
@@ -304,6 +305,107 @@ def _stop(self, start_params):
 exports["RawSerialPort"] = SerialPortExport
 
 
+@attr.s(eq=False)
+class CANPortExport(ResourceExport):
+    """ResourceExport for a USB and Raw CANPort"""
+
+    def __attrs_post_init__(self):
+        super().__attrs_post_init__()
+        if self.cls == "RawCANPort":
+            from ..resource.canport import RawCANPort
+
+            self.local = RawCANPort(target=None, name=None, **self.local_params)
+        elif self.cls == "USBCANPort":
+            from ..resource.udev import USBCANPort
+
+            self.local = USBCANPort(target=None, name=None, **self.local_params)
+        self.data["cls"] = "NetworkCANPort"
+        self.child = None
+        self.port = None
+        self.cannelloni_bin = shutil.which("cannelloni")
+        if self.cannelloni_bin is None:
+            self.cannelloni_bin = "/usr/bin/cannelloni"
+            warnings.warn("cannelloni binary not found, falling back to %s", self.cannelloni_bin)
+
+    def __del__(self):
+        if self.child is not None:
+            self.stop()
+
+    def _get_start_params(self):
+        return {
+            "ifname": self.local.ifname,
+        }
+
+    def _get_params(self):
+        """Helper function to return parameters"""
+        return {
+            "host": self.host,
+            "port": self.port,
+            "speed": self.local.speed,
+            "extra": {
+                "ifname": self.local.ifname,
+            },
+        }
+
+    def _start(self, start_params):
+        """Start ``cannelloni`` subprocess"""
+        assert self.local.avail
+        assert self.child is None
+        self.port = get_free_port()
+
+        # XXX How to handle the permissions on the exporer? Via the helper with sudo?
+        cmd_down = f"ip link set {self.local.ifname} down"
+        processwrapper.check_output(cmd_down.split())
+
+        cmd_type_bitrate = f"ip link set {self.local.ifname} type can bitrate {self.local.speed}"
+        processwrapper.check_output(cmd_type_bitrate.split())
+
+        cmd_up = f"ip link set {self.local.ifname} up"
+        processwrapper.check_output(cmd_up.split())
+
+        cmd_cannelloni = [
+            self.cannelloni_bin,
+            "-C", "s",
+            # XXX Set "no peer checking" mode. Is it ok? It seems so for serial...
+            "-p",
+            "-I", f"{self.local.ifname}",
+            "-l", f"{self.port}",
+            ]
+        self.logger.info("Starting cannelloni with: %s", " ".join(cmd_cannelloni))
+        self.child = subprocess.Popen(cmd_cannelloni)
+        try:
+            self.child.wait(timeout=2)
+            raise ExporterError(f"cannelloni for {start_params['ifname']} exited immediately")
+        except subprocess.TimeoutExpired:
+            # good, cannelloni didn't exit immediately
+            pass
+        self.logger.info("cannelloni started for %s on port %d", start_params["ifname"], self.port)
+
+    def _stop(self, start_params):
+        """Stop ``cannelloni`` subprocess and disable the interface"""
+        assert self.child
+        child = self.child
+        self.child = None
+        port = self.port
+        self.port = None
+        child.terminate()
+        try:
+            child.wait(3.0)
+        except subprocess.TimeoutExpired:
+            self.logger.warning("cannelloni for %s still running after SIGTERM", start_params["ifname"])
+            log_subprocess_kernel_stack(self.logger, child)
+            child.kill()
+            child.wait(1.0)
+        self.logger.info("cannelloni stopped for %s on port %d", start_params["ifname"], port)
+
+        cmd_down = f"ip link set {start_params['ifname']} down"
+        processwrapper.check_output(cmd_down.split())
+
+
+exports["USBCANPort"] = CANPortExport
+exports["RawCANPort"] = CANPortExport
+
+
 @attr.s(eq=False)
 class NetworkInterfaceExport(ResourceExport):
     """ResourceExport for a network interface"""

labgrid/resource/__init__.py

@@ -1,5 +1,5 @@
 from .base import CANPort, SerialPort, NetworkInterface, EthernetPort, SysfsGPIO
-from .canport import RawCANPort
+from .canport import NetworkCANPort, RawCANPort
 from .ethernetport import SNMPEthernetPort
 from .serialport import RawSerialPort, NetworkSerialPort
 from .modbus import ModbusTCPCoil

labgrid/resource/canport.py

@@ -2,7 +2,7 @@
 
 from ..factory import target_factory
 from .base import CANPort
-from .common import Resource
+from .common import NetworkResource, Resource
 
 
 @target_factory.reg_resource
@@ -13,3 +13,11 @@ def __attrs_post_init__(self):
         super().__attrs_post_init__()
         if self.ifname is None:
             raise ValueError("RawCANPort must be configured with an interface name")
+
+
+@target_factory.reg_resource
+@attr.s(eq=False)
+class NetworkCANPort(NetworkResource, CANPort):
+    """A NetworkCANPort is a remotely accessible CAN port, accessed via cannelloni."""
+
+    port = attr.ib(default=None, validator=attr.validators.optional(attr.validators.instance_of(int)))