turned transport type usages of raw and virtual across the board to an enumerated type

daemon/core/nodes/interface.py

@@ -4,12 +4,12 @@ virtual ethernet classes that implement the interfaces available under Linux.
 
 import logging
 import time
-from typing import TYPE_CHECKING, Callable, Dict, List, Tuple
+from typing import TYPE_CHECKING, Callable, Dict, List, Optional, Tuple
 
 from core import utils
-from core.emulator.enumerations import MessageFlags
+from core.emulator.enumerations import MessageFlags, TransportType
 from core.errors import CoreCommandError
-from core.nodes.netclient import get_net_client
+from core.nodes.netclient import LinuxNetClient, get_net_client
 
 if TYPE_CHECKING:
     from core.emulator.distributed import DistributedServer
@@ -42,32 +42,30 @@ class CoreInterface:
         :param server: remote server node
             will run on, default is None for localhost
         """
-        self.session = session
-        self.node = node
-        self.name = name
-        self.localname = localname
-        self.up = False
-        if not isinstance(mtu, int):
-            raise ValueError
-        self.mtu = mtu
-        self.net = None
-        self.othernet = None
+        self.session: "Session" = session
+        self.node: "CoreNode" = node
+        self.name: str = name
+        self.localname: str = localname
+        self.up: bool = False
+        self.mtu: int = mtu
+        self.net: Optional[CoreNetworkBase] = None
+        self.othernet: Optional[CoreNetworkBase] = None
         self._params = {}
-        self.addrlist = []
-        self.hwaddr = None
+        self.addrlist: List[str] = []
+        self.hwaddr: Optional[str] = None
         # placeholder position hook
-        self.poshook = lambda x: None
+        self.poshook: Callable[[CoreInterface], None] = lambda x: None
         # used with EMANE
-        self.transport_type = None
+        self.transport_type: Optional[TransportType] = None
         # node interface index
-        self.netindex = None
+        self.netindex: Optional[int] = None
         # net interface index
-        self.netifi = None
+        self.netifi: Optional[int] = None
         # index used to find flow data
-        self.flow_id = None
-        self.server = server
+        self.flow_id: Optional[int] = None
+        self.server: Optional["DistributedServer"] = server
         use_ovs = session.options.get_config("ovs") == "True"
-        self.net_client = get_net_client(use_ovs, self.host_cmd)
+        self.net_client: LinuxNetClient = get_net_client(use_ovs, self.host_cmd)
 
     def host_cmd(
         self,
@@ -330,7 +328,7 @@ class TunTap(CoreInterface):
         :param start: start flag
         """
         super().__init__(session, node, name, localname, mtu, server)
-        self.transport_type = "virtual"
+        self.transport_type = TransportType.VIRTUAL
         if start:
             self.startup()
 
@@ -516,7 +514,7 @@ class GreTap(CoreInterface):
         sessionid = session.short_session_id()
         localname = f"gt.{self.id}.{sessionid}"
         super().__init__(session, node, name, localname, mtu, server)
-        self.transport_type = "raw"
+        self.transport_type = TransportType.RAW
         if not start:
             return
         if remoteip is None:

daemon/core/nodes/physical.py

@@ -10,7 +10,7 @@ from typing import IO, TYPE_CHECKING, List, Optional, Tuple
 from core import utils
 from core.constants import MOUNT_BIN, UMOUNT_BIN
 from core.emulator.distributed import DistributedServer
-from core.emulator.enumerations import NodeTypes
+from core.emulator.enumerations import NodeTypes, TransportType
 from core.errors import CoreCommandError, CoreError
 from core.nodes.base import CoreNetworkBase, CoreNodeBase
 from core.nodes.interface import CoreInterface, Veth
@@ -281,7 +281,7 @@ class Rj45Node(CoreNodeBase):
         """
         super().__init__(session, _id, name, start, server)
         self.interface = CoreInterface(session, self, name, name, mtu, server)
-        self.interface.transport_type = "raw"
+        self.interface.transport_type = TransportType.RAW
         self.lock: threading.RLock = threading.RLock()
         self.ifindex: Optional[int] = None
         self.old_up: bool = False