Exceptions polish

src/Kathara/cli/command/LstartCommand.py

@@ -164,7 +164,7 @@ def run(self, current_path: str, argv: List[str]) -> Lab:
             logging.info(format_headers())
 
         if len(lab.machines) <= 0:
-            raise EmptyLabError("No devices in the current network scenario. Exiting...")
+            raise EmptyLabError()
 
         try:
             options = OptionParser.parse(args['options'])

src/Kathara/exceptions.py

@@ -17,21 +17,23 @@ class InvocationError(Exception):
 
 # Settings Exceptions
 class SettingsError(Exception):
-    def __init__(self, message) -> None:
-        super().__init__("Settings file is not valid: %s\nFix it or delete it before launching." % message)
+    def __init__(self, message: str) -> None:
+        super().__init__(f"Settings file is not valid: {message} Fix it or delete it before launching.")
 
 
 class SettingsNotFoundError(Exception):
-    pass
+    def __init__(self, path: str) -> None:
+        super().__init__(f"Settings file not found in path `{path}`.")
 
 
 class DockerDaemonConnectionError(Exception):
-    pass
+    def __init__(self, message: str) -> None:
+        super().__init__(f"Cannot connect to Docker Daemon: {message}")
 
 
 class NotSupportedError(Exception):
-    def __init__(self, message) -> None:
-        super().__init__("Not Supported: %s" % message)
+    def __init__(self, message: str) -> None:
+        super().__init__(f"Not Supported: {message}")
 
 
 # OS Exceptions
@@ -43,6 +45,11 @@ class InterfaceNotFoundError(Exception):
     pass
 
 
+class HostArchitectureError(Exception):
+    def __init__(self, architecture: str) -> None:
+        super().__init__(f"Not implemented for host architecture `{architecture}`.")
+
+
 # Lab Exceptions
 class LabAlreadyExistsError(Exception):
     pass
@@ -53,7 +60,8 @@ class LabNotFoundError(Exception):
 
 
 class EmptyLabError(Exception):
-    pass
+    def __init__(self) -> None:
+        super().__init__("No devices in the current network scenario.")
 
 
 class MachineDependencyError(Exception):
@@ -66,18 +74,20 @@ class MountDeniedError(Exception):
 
 
 class MachineAlreadyExistsError(Exception):
-    pass
+    def __init__(self, machine_name: str) -> None:
+        super().__init__(f"Device with name `{machine_name}` already exists.")
 
 
 class NonSequentialMachineInterfaceError(Exception):
-    pass
+    def __init__(self, iface_num: int, machine_name: str) -> None:
+        super().__init__(f"Interface `{iface_num}` missing on device `{machine_name}`.")
 
 
 class MachineOptionError(Exception):
     pass
 
 
-class MachineCollisionDomainConflictError(Exception):
+class MachineCollisionDomainError(Exception):
     pass
 
 
@@ -86,48 +96,51 @@ class MachineNotFoundError(Exception):
 
 
 class MachineNotReadyError(Exception):
-    pass
+    def __init__(self, machine_name: str) -> None:
+        super().__init__(f"Device `{machine_name}` is not ready.")
 
 
 # Link Exceptions
 class LinkNotFoundError(Exception):
     pass
 
 
-# Architecture Excpetion
-class ArchitectureError(Exception):
-    pass
-
-
 # Test Exceptions
 class TestError(Exception):
     pass
 
 
 class MachineSignatureNotFoundError(TestError):
-    pass
+    __slots__ = ['machine_name']
+
+    def __init__(self, machine_name: str):
+        self.machine_name: str = machine_name
+
+    def __str__(self):
+        return f"Signature for device `{self.machine_name}` not found!"
 
 
 # Docker Exceptions
 class InvalidImageArchitectureError(ValueError):
     __slots__ = ['image_name', 'arch']
 
-    def __init__(self, image_name, arch):
-        self.image_name = image_name
-        self.arch = arch
+    def __init__(self, image_name: str, arch: str):
+        self.image_name: str = image_name
+        self.arch: str = arch
 
     def __str__(self):
         return f"Docker Image `{self.image_name}` is not compatible with your host architecture `{self.arch}`"
 
 
 class DockerImageNotFoundError(Exception):
-    pass
+    def __init__(self, image_name: str) -> None:
+        super().__init__(f"Docker Image `{image_name}` is not available neither on Docker Hub nor in local repository!")
 
 
 class DockerPluginError(Exception):
     pass
 
 
-# Kubernetes Exception
+# Kubernetes Exceptions
 class KubernetesConfigMapError(Exception):
     pass

src/Kathara/manager/docker/DockerImage.py

@@ -161,10 +161,7 @@ def _check_and_pull(self, image_name: str, pull: bool = True) -> None:
                         "no Internet connection is available to pull it from Docker Hub." % image_name
                     )
                 else:
-                    raise DockerImageNotFoundError(
-                        "Docker Image `%s` is not available neither on Docker Hub "
-                        "nor in local repository!" % image_name
-                    )
+                    raise DockerImageNotFoundError(image_name)
             except InvalidImageArchitectureError as e:
                 raise e
 

src/Kathara/manager/docker/DockerMachine.py

@@ -175,7 +175,7 @@ def create(self, machine: Machine) -> None:
         containers = self.get_machines_api_objects_by_filters(machine_name=machine.name, lab_hash=machine.lab.hash,
                                                               user=utils.get_current_user_name())
         if containers:
-            raise MachineAlreadyExistsError("Device with name `%s` already exists." % machine.name)
+            raise MachineAlreadyExistsError(machine.name)
 
         image = machine.get_image()
         memory = machine.get_mem()

src/Kathara/manager/docker/DockerManager.py

@@ -15,7 +15,7 @@
 from .stats.DockerMachineStats import DockerMachineStats
 from ... import utils
 from ...decorators import privileged
-from ...exceptions import DockerDaemonConnectionError, LinkNotFoundError, MachineCollisionDomainConflictError, \
+from ...exceptions import DockerDaemonConnectionError, LinkNotFoundError, MachineCollisionDomainError, \
     InvocationError, LabNotFoundError
 from ...foundation.manager.IManager import IManager
 from ...model.Lab import Lab
@@ -55,9 +55,9 @@ def check_docker(*args, **kw):
         try:
             client.ping()
         except RequestsConnectionError as e:
-            raise DockerDaemonConnectionError("Can not connect to Docker Daemon. %s" % str(e))
+            raise DockerDaemonConnectionError(str(e))
         except pywintypes.error as e:
-            raise DockerDaemonConnectionError("Can not connect to Docker Daemon. %s" % str(e))
+            raise DockerDaemonConnectionError(str(e))
 
     return check_docker
 
@@ -173,7 +173,7 @@ def connect_machine_to_link(self, machine: Machine, link: Link) -> None:
             raise LabNotFoundError(f"Collision domain `{link.name}` is not associated to a network scenario.")
 
         if machine.name in link.machines:
-            raise MachineCollisionDomainConflictError(
+            raise MachineCollisionDomainError(
                 f"Device `{machine.name}` is already connected to collision domain `{link.name}`."
             )
 
@@ -205,7 +205,7 @@ def disconnect_machine_from_link(self, machine: Machine, link: Link) -> None:
             raise LabNotFoundError(f"Collision domain `{link.name}` is not associated to a network scenario.")
 
         if machine.name not in link.machines:
-            raise MachineCollisionDomainConflictError(
+            raise MachineCollisionDomainError(
                 f"Device `{machine.name}` is not connected to collision domain `{link.name}`."
             )
 

src/Kathara/manager/kubernetes/KubernetesMachine.py

@@ -229,7 +229,7 @@ def create(self, machine: Machine) -> None:
                                                                           )
         except ApiException as e:
             if e.status == 409 and 'Conflict' in e.reason:
-                raise MachineAlreadyExistsError("Device with name `%s` already exists." % machine.name)
+                raise MachineAlreadyExistsError(machine.name)
             else:
                 raise e
 
@@ -503,7 +503,7 @@ def connect(self, lab_hash: str, machine_name: str, shell: Union[str, List[str]]
         deployment = pods.pop()
 
         if 'Running' not in deployment.status.phase:
-            raise MachineNotReadyError('Device `%s` is not ready.' % machine_name)
+            raise MachineNotReadyError(machine_name)
 
         if not shell:
             shell_env_value = self.get_env_var_value_from_pod(deployment, "_MEGALOS_SHELL")

src/Kathara/model/Lab.py

@@ -313,6 +313,6 @@ def __str__(self) -> str:
             lab_info += "Email: %s\n" % self.email
 
         if self.web:
-            lab_info += "Website: %s" % self.web
+            lab_info += "Website: %s\n" % self.web
 
-        return lab_info
+        return lab_info[0:-1]  # Remove trailing new line

src/Kathara/model/Machine.py

@@ -13,7 +13,7 @@
 from . import Link as LinkPackage
 from .Link import Link
 from .. import utils
-from ..exceptions import NonSequentialMachineInterfaceError, MachineOptionError, MachineCollisionDomainConflictError
+from ..exceptions import NonSequentialMachineInterfaceError, MachineOptionError, MachineCollisionDomainError
 from ..setting.Setting import Setting
 
 
@@ -105,10 +105,10 @@ def add_interface(self, link: 'LinkPackage.Link', number: int = None) -> None:
             number = len(self.interfaces.keys())
 
         if number in self.interfaces:
-            raise MachineCollisionDomainConflictError(f"Interface {number} already set on device `{self.name}`.")
+            raise MachineCollisionDomainError(f"Interface {number} already set on device `{self.name}`.")
 
         if self.name in link.machines:
-            raise MachineCollisionDomainConflictError(
+            raise MachineCollisionDomainError(
                 f"Device `{self.name}` is already connected to collision domain `{link.name}`."
             )
 
@@ -128,7 +128,7 @@ def remove_interface(self, link: 'LinkPackage.Link') -> None:
             MachineCollisionDomainConflictError: If the device is not connected to the collision domain.
         """
         if self.name not in link.machines:
-            raise MachineCollisionDomainConflictError(
+            raise MachineCollisionDomainError(
                 f"Device `{self.name}` is not connected to collision domain `{link.name}`.")
 
         self.interfaces = collections.OrderedDict(
@@ -225,7 +225,7 @@ def check(self) -> None:
 
         for i, (num_iface, _) in enumerate(sorted_interfaces):
             if num_iface != i:
-                raise NonSequentialMachineInterfaceError("Interface %d missing on device %s." % (i, self.name))
+                raise NonSequentialMachineInterfaceError(i, self.name)
 
         self.interfaces = collections.OrderedDict(sorted_interfaces)
 

src/Kathara/parser/netkit/DepParser.py

@@ -64,7 +64,7 @@ def parse(path: str) -> Optional[List[str]]:
                     # Dependencies are saved as dependencies[machine3] = [machine1, machine2]
                     dependencies[key] = deps
                 else:
-                    raise SyntaxError(f"[ERROR] In lab.dep - line {line_number}: Syntax error.")
+                    raise SyntaxError(f"In lab.dep - line {line_number}: Syntax error.")
 
             line_number += 1
             line = dep_mem_file.readline().decode('utf-8')

src/Kathara/parser/netkit/ExtParser.py

@@ -61,15 +61,14 @@ def parse(path: str) -> Optional[Dict[str, List[ExternalLink]]]:
 
                 if vlan:
                     if 0 <= vlan >= 4095:
-                        raise ValueError(f"[ERROR] In file lab.ext, line {line_number}: "
-                                         "VLAN ID must be in range [1, 4094].")
+                        raise ValueError(f"In file lab.ext, line {line_number}: VLAN ID must be in range [1, 4094].")
 
                 if link not in external_links:
                     external_links[link] = []
 
                 external_links[link].append(ExternalLink(interface, vlan))
             elif not line.startswith('#') and line.strip():
-                raise SyntaxError(f"[ERROR] In file lab.ext, line {line_number} malformed.")
+                raise SyntaxError(f"In file lab.ext, line {line_number} malformed.")
 
             line_number += 1
             line = ext_mem_file.readline().decode('utf-8')

src/Kathara/parser/netkit/LabParser.py

@@ -49,7 +49,7 @@ def parse(path: str) -> Lab:
                 value = matches.group("value").replace('"', '').replace("'", '')
 
                 if key in RESERVED_MACHINE_NAMES:
-                    raise ValueError("[ERROR] In line %d: "
+                    raise ValueError("In line %d: "
                                      "`%s` is a reserved name, you can not use it for a device." % (line_number, key))
 
                 try:
@@ -59,9 +59,8 @@ def parse(path: str) -> Lab:
                     if re.search(r"^\w+$", value):
                         lab.connect_machine_to_link(key, value, machine_iface_number=interface_number)
                     else:
-                        raise ValueError("[ERROR] In line %d: "
-                                         "Collision domain `%s` contains non-alphanumeric characters." % (line_number,
-                                                                                                          value))
+                        raise ValueError("In line %d: Collision domain `%s` contains non-alphanumeric characters." %
+                                         (line_number, value))
                 except ValueError:
                     # Not an interface, add it to the machine metas.
                     lab.assign_meta_to_machine(key, arg, value)
@@ -74,7 +73,7 @@ def parse(path: str) -> Lab:
                             not line.startswith("LAB_AUTHOR=") and \
                             not line.startswith("LAB_EMAIL=") and \
                             not line.startswith("LAB_WEB="):
-                        raise SyntaxError("[ERROR] In line %d: Invalid characters `%s`." % (line_number, line))
+                        raise SyntaxError("In line %d: Invalid characters `%s`." % (line_number, line))
                     else:
                         (key, value) = line.split("=")
                         key = key.replace("LAB_", "").lower()

src/Kathara/setting/Setting.py

@@ -99,7 +99,7 @@ def load_from_disk(self, path: Optional[str] = None) -> None:
         settings_path = os.path.join(path, SETTINGS_FILENAME) if path is not None else DEFAULT_SETTINGS_PATH
 
         if not os.path.exists(settings_path):  # Requested settings file doesn't exist, throw exception
-            raise SettingsNotFoundError("Settings file not found in specified path.")
+            raise SettingsNotFoundError(settings_path)
         else:  # Requested settings file exists, read it and check values
             settings = {}
             with open(settings_path, 'r') as settings_file:

src/Kathara/test/BuiltinTest.py

@@ -39,7 +39,7 @@ def test(self) -> bool:
                 with open(machine_signature_path, 'r') as machine_signature_file:
                     machine_signature = json.loads(machine_signature_file.read())
             else:
-                raise MachineSignatureNotFoundError("Signature for device `%s` not found! Exiting..." % machine_name)
+                raise MachineSignatureNotFoundError(machine_name)
 
             # Save machine state into result file
             machine_result_path = "%s/%s.builtin" % (self.results_path, machine.name)

src/Kathara/test/UserTest.py

@@ -47,9 +47,7 @@ def test(self) -> bool:
                     with open(machine_signature_path, 'r') as machine_signature_file:
                         machine_signature = machine_signature_file.read()
                 else:
-                    raise MachineSignatureNotFoundError("Signature for device `%s` not found! Exiting..." %
-                                                        machine_name
-                                                        )
+                    raise MachineSignatureNotFoundError(machine_name)
 
                 # Save machine state into result file
                 machine_result_path = "%s/%s.user" % (self.results_path, machine.name)

src/Kathara/utils.py

@@ -20,7 +20,7 @@
 from binaryornot.check import is_binary
 from slug import slug
 
-from .exceptions import ArchitectureError
+from .exceptions import HostArchitectureError
 
 # Platforms constants definition.
 MAC_OS: str = "darwin"
@@ -139,7 +139,7 @@ def get_architecture() -> str:
     elif architecture == "armv6l":
         return "armv6"
     else:
-        raise ArchitectureError("Not implemented for %s." % architecture)
+        raise HostArchitectureError(architecture)
 
 
 def convert_win_2_linux(filename: str) -> bytes: