gns3-server 3.0.0__py3-none-any.whl

gns3server/compute/ubridge/ubridge_hypervisor.py

@@ -0,0 +1,285 @@
+#
+# Copyright (C) 2015 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import re
+import time
+import logging
+import asyncio
+
+from gns3server.utils.asyncio import locking
+from .ubridge_error import UbridgeError
+
+log = logging.getLogger(__name__)
+
+
+class UBridgeHypervisor:
+
+    """
+    Creates a new connection to uBridge hypervisor.
+
+    :param host: the hostname or ip address string of the uBridge hypervisor
+    :param port: the tcp port integer
+    :param timeout: timeout integer for how long to wait for a response to commands sent to the
+    hypervisor (defaults to 30 seconds)
+    """
+
+    # Used to parse Ubridge response codes
+    error_re = re.compile(r"""^2[0-9]{2}-""")
+    success_re = re.compile(r"""^1[0-9]{2}\s{1}""")
+
+    def __init__(self, host, port, timeout=30.0):
+
+        self._host = host
+        self._port = port
+        self._version = "N/A"
+        self._timeout = timeout
+        self._reader = None
+        self._writer = None
+
+    async def connect(self, timeout=10):
+        """
+        Connects to the hypervisor.
+        """
+
+        # connect to a local address by default
+        # if listening to all addresses (IPv4 or IPv6)
+        if self._host == "0.0.0.0":
+            host = "127.0.0.1"
+        elif self._host == "::":
+            host = "::1"
+        else:
+            host = self._host
+
+        begin = time.time()
+        connection_success = False
+        last_exception = None
+        while time.time() - begin < timeout:
+            await asyncio.sleep(0.1)
+            try:
+                self._reader, self._writer = await asyncio.open_connection(host, self._port)
+            except OSError as e:
+                last_exception = e
+                continue
+            connection_success = True
+            break
+
+        if not connection_success:
+            raise UbridgeError(f"Couldn't connect to hypervisor on {host}:{self._port} :{last_exception}")
+        else:
+            log.info(f"Connected to uBridge hypervisor on {host}:{self._port} after {time.time() - begin:.4f} seconds")
+
+        try:
+            await asyncio.sleep(0.1)
+            version = await self.send("hypervisor version")
+            self._version = version[0].split("-", 1)[0]
+        except IndexError:
+            self._version = "Unknown"
+
+    @property
+    def version(self):
+        """
+        Returns uBridge version.
+
+        :returns: version string
+        """
+
+        return self._version
+
+    async def close(self):
+        """
+        Closes the connection to this hypervisor (but leave it running).
+        """
+
+        await self.send("hypervisor close")
+        self._writer.close()
+        self._reader, self._writer = None
+
+    async def stop(self):
+        """
+        Stops this hypervisor (will no longer run).
+        """
+
+        try:
+            # try to properly stop the hypervisor
+            await self.send("hypervisor stop")
+        except UbridgeError:
+            pass
+        try:
+            if self._writer is not None:
+                await self._writer.drain()
+                self._writer.close()
+        except OSError as e:
+            log.debug(f"Stopping hypervisor {self._host}:{self._port} {e}")
+        self._reader = self._writer = None
+
+    async def reset(self):
+        """
+        Resets this hypervisor (used to get an empty configuration).
+        """
+
+        await self.send("hypervisor reset")
+
+    @property
+    def port(self):
+        """
+        Returns the port used to start the hypervisor.
+
+        :returns: port number (integer)
+        """
+
+        return self._port
+
+    @port.setter
+    def port(self, port):
+        """
+        Sets the port used to start the hypervisor.
+
+        :param port: port number (integer)
+        """
+
+        self._port = port
+
+    @property
+    def host(self):
+        """
+        Returns the host (binding) used to start the hypervisor.
+
+        :returns: host/address (string)
+        """
+
+        return self._host
+
+    @host.setter
+    def host(self, host):
+        """
+        Sets the host (binding) used to start the hypervisor.
+
+        :param host: host/address (string)
+        """
+
+        self._host = host
+
+    @locking
+    async def send(self, command):
+        """
+        Sends commands to this hypervisor.
+
+        :param command: a uBridge hypervisor command
+
+        :returns: results as a list
+        """
+
+        # uBridge responses are of the form:
+        #   1xx yyyyyy\r\n
+        #   1xx yyyyyy\r\n
+        #   ...
+        #   100-yyyy\r\n
+        # or
+        #   2xx-yyyy\r\n
+        #
+        # Where 1xx is a code from 100-199 for a success or 200-299 for an error
+        # The result might be multiple lines and might be less than the buffer size
+        # but still have more data. The only thing we know for sure is the last line
+        # will begin with '100-' or a '2xx-' and end with '\r\n'
+
+        if self._writer is None or self._reader is None:
+            raise UbridgeError("Not connected")
+
+        try:
+            command = command.strip() + "\n"
+            log.debug(f"sending {command}")
+            self._writer.write(command.encode())
+            await self._writer.drain()
+        except OSError as e:
+            raise UbridgeError(
+                "Lost communication with {host}:{port} when sending command '{command}': {error}, uBridge process running: {run}".format(
+                    host=self._host, port=self._port, command=command, error=e, run=self.is_running()
+                )
+            )
+
+        # Now retrieve the result
+        data = []
+        buf = ""
+        retries = 0
+        max_retries = 10
+        while True:
+            try:
+                try:
+                    chunk = await self._reader.read(1024)
+                except asyncio.CancelledError:
+                    # task has been canceled but continue to read
+                    # any remaining data sent by the hypervisor
+                    continue
+                except ConnectionResetError as e:
+                    # Sometimes WinError 64 (ERROR_NETNAME_DELETED) is returned here on Windows.
+                    # These happen if connection reset is received before IOCP could complete
+                    # a previous operation. Ignore and try again....
+                    log.warning(f"Connection reset received while reading uBridge response: {e}")
+                    continue
+                if not chunk:
+                    if retries > max_retries:
+                        raise UbridgeError(
+                            "No data returned from {host}:{port} after sending command '{command}', uBridge process running: {run}".format(
+                                host=self._host, port=self._port, command=command, run=self.is_running()
+                            )
+                        )
+                    else:
+                        retries += 1
+                        await asyncio.sleep(0.5)
+                        continue
+                retries = 0
+                buf += chunk.decode("utf-8")
+            except OSError as e:
+                raise UbridgeError(
+                    "Lost communication with {host}:{port} after sending command '{command}': {error}, uBridge process running: {run}".format(
+                        host=self._host, port=self._port, command=command, error=e, run=self.is_running()
+                    )
+                )
+
+            # If the buffer doesn't end in '\n' then we can't be done
+            try:
+                if buf[-1] != "\n":
+                    continue
+            except IndexError:
+                raise UbridgeError(
+                    "Could not communicate with {host}:{port} after sending command '{command}', uBridge process running: {run}".format(
+                        host=self._host, port=self._port, command=command, run=self.is_running()
+                    )
+                )
+
+            data += buf.split("\r\n")
+            if data[-1] == "":
+                data.pop()
+            buf = ""
+
+            # Does it contain an error code?
+            if self.error_re.search(data[-1]):
+                raise UbridgeError(data[-1][4:])
+
+            # Or does the last line begin with '100-'? Then we are done!
+            if data[-1][:4] == "100-":
+                data[-1] = data[-1][4:]
+                if data[-1] == "OK":
+                    data.pop()
+                break
+
+        # Remove success responses codes
+        for index in range(len(data)):
+            if self.success_re.search(data[index]):
+                data[index] = data[index][4:]
+
+        log.debug(f"returned result {data}")
+        return data

gns3server/compute/virtualbox/__init__.py

@@ -0,0 +1,212 @@
+#
+# Copyright (C) 2015 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+VirtualBox server module.
+"""
+
+import os
+import re
+import sys
+import shutil
+import asyncio
+import subprocess
+import logging
+
+log = logging.getLogger(__name__)
+
+from ..base_manager import BaseManager
+from .virtualbox_vm import VirtualBoxVM
+from .virtualbox_error import VirtualBoxError
+
+
+class VirtualBox(BaseManager):
+
+    _NODE_CLASS = VirtualBoxVM
+
+    def __init__(self):
+
+        super().__init__()
+        self._vboxmanage_path = None
+        self._execute_lock = asyncio.Lock()
+
+    @property
+    def vboxmanage_path(self):
+        """
+        Returns the path to VBoxManage.
+
+        :returns: path
+        """
+
+        return self._vboxmanage_path
+
+    def find_vboxmanage(self):
+
+        # look for VBoxManage
+        vboxmanage_path = self.config.settings.VirtualBox.vboxmanage_path
+        if vboxmanage_path:
+            if not os.path.isabs(vboxmanage_path):
+                vboxmanage_path = shutil.which(vboxmanage_path)
+        else:
+            log.info("A path to VBoxManage has not been configured, trying to find it...")
+            if sys.platform.startswith("darwin"):
+                vboxmanage_path_osx = "/Applications/VirtualBox.app/Contents/MacOS/VBoxManage"
+                if os.path.exists(vboxmanage_path_osx):
+                    vboxmanage_path = vboxmanage_path_osx
+            if not vboxmanage_path:
+                vboxmanage_path = shutil.which("vboxmanage")
+
+        if vboxmanage_path and not os.path.exists(vboxmanage_path):
+            log.error(f"VBoxManage path '{vboxmanage_path}' doesn't exist")
+
+        if not vboxmanage_path:
+            raise VirtualBoxError("Could not find VBoxManage, please reboot if VirtualBox has just been installed")
+        if not os.path.isfile(vboxmanage_path):
+            raise VirtualBoxError(f"VBoxManage '{vboxmanage_path}' is not accessible")
+        if not os.access(vboxmanage_path, os.X_OK):
+            raise VirtualBoxError("VBoxManage is not executable")
+        if os.path.basename(vboxmanage_path) not in ["VBoxManage", "VBoxManage.exe", "vboxmanage"]:
+            raise VirtualBoxError(f"Invalid VBoxManage executable name {os.path.basename(vboxmanage_path)}")
+
+        self._vboxmanage_path = vboxmanage_path
+        return vboxmanage_path
+
+    async def execute(self, subcommand, args, timeout=60):
+
+        # We use a lock prevent parallel execution due to strange errors
+        # reported by a user and reproduced by us.
+        # https://github.com/GNS3/gns3-gui/issues/261
+        async with self._execute_lock:
+            vboxmanage_path = self.vboxmanage_path
+            if not vboxmanage_path:
+                vboxmanage_path = self.find_vboxmanage()
+            if not vboxmanage_path:
+                raise VirtualBoxError("Could not find VBoxManage")
+
+            command = [vboxmanage_path, "--nologo", subcommand]
+            command.extend(args)
+            command_string = " ".join(command)
+            log.info(f"Executing VBoxManage with command: {command_string}")
+            env = os.environ.copy()
+            env["LANG"] = "en"  # force english output because we rely on it to parse the output
+            try:
+                process = await asyncio.create_subprocess_exec(
+                    *command,
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                    env=env
+                )
+            except (OSError, subprocess.SubprocessError) as e:
+                raise VirtualBoxError(f"Could not execute VBoxManage: {e}")
+
+            try:
+                stdout_data, stderr_data = await asyncio.wait_for(process.communicate(), timeout=timeout)
+            except asyncio.TimeoutError:
+                raise VirtualBoxError(f"VBoxManage has timed out after {timeout} seconds!")
+
+            if process.returncode:
+                vboxmanage_error = stderr_data.decode("utf-8", errors="ignore")
+                raise VirtualBoxError(f"VirtualBox has returned an error: {vboxmanage_error}")
+
+            return stdout_data.decode("utf-8", errors="ignore").splitlines()
+
+    async def _find_inaccessible_hdd_files(self):
+        """
+        Finds inaccessible disk files (to clean up the VirtualBox media manager)
+        """
+
+        hdds = []
+        try:
+            properties = await self.execute("list", ["hdds"])
+        # If VirtualBox is not available we have no inaccessible hdd
+        except VirtualBoxError:
+            return hdds
+
+        flag_inaccessible = False
+        for prop in properties:
+            try:
+                name, value = prop.split(":", 1)
+            except ValueError:
+                continue
+            if name.strip() == "State" and value.strip() == "inaccessible":
+                flag_inaccessible = True
+            if flag_inaccessible and name.strip() == "Location":
+                hdds.append(value.strip())
+                flag_inaccessible = False
+        return reversed(hdds)
+
+    async def project_closed(self, project):
+        """
+        Called when a project is closed.
+
+        :param project: Project instance
+        """
+
+        await super().project_closed(project)
+        hdd_files_to_close = await self._find_inaccessible_hdd_files()
+        for hdd_file in hdd_files_to_close:
+            log.info(f"Closing VirtualBox VM disk file {os.path.basename(hdd_file)}")
+            try:
+                await self.execute("closemedium", ["disk", hdd_file])
+            except VirtualBoxError as e:
+                log.warning(f"Could not close VirtualBox VM disk file {os.path.basename(hdd_file)}: {e}")
+                continue
+
+    async def list_vms(self, allow_clone=False):
+        """
+        Gets VirtualBox VM list.
+        """
+
+        vbox_vms = []
+        result = await self.execute("list", ["vms"])
+        for line in result:
+            if len(line) == 0 or line[0] != '"' or line[-1:] != "}":
+                continue  # Broken output (perhaps a carriage return in VM name)
+            match = re.search(r"\"(.*)\"\ {(.*)}", line)
+            if not match:
+                continue
+            vmname = match.group(1)
+            uuid = match.group(2)
+            if vmname == "<inaccessible>":
+                continue  # ignore inaccessible VMs
+            extra_data = await self.execute("getextradata", [uuid, "GNS3/Clone"])
+            if allow_clone or len(extra_data) == 0 or not extra_data[0].strip() == "Value: yes":
+                # get the amount of RAM
+                info_results = await self.execute("showvminfo", [uuid, "--machinereadable"])
+                ram = 0
+                for info in info_results:
+                    try:
+                        name, value = info.split("=", 1)
+                        if name.strip() == "memory":
+                            ram = int(value.strip())
+                            break
+                    except ValueError:
+                        continue
+                vbox_vms.append({"vmname": vmname, "ram": ram})
+        return vbox_vms
+
+    @staticmethod
+    def get_legacy_vm_workdir(legacy_vm_id, name):
+        """
+        Returns the name of the legacy working directory name for a node.
+
+        :param legacy_vm_id: legacy node identifier (not used)
+        :param name: node name
+
+        :returns: working directory name
+        """
+
+        return os.path.join("vbox", f"{name}")

gns3server/compute/virtualbox/virtualbox_error.py

@@ -0,0 +1,26 @@
+#
+# Copyright (C) 2015 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+Custom exceptions for the VirtualBox module.
+"""
+
+from ..error import NodeError
+
+
+class VirtualBoxError(NodeError):
+
+    pass