1.5.3

.github/ISSUE_TEMPLATE/gns3-bug-report.md

@@ -1,34 +0,0 @@
----
-name: GNS3 bug report
-about: Create a report to help us fix a bug
-title: 'Short description of the bug'
-labels: Bug
-assignees: ''
-
----
-
-**Before you start**
-Please open an issue only if you suspect there is a bug or any problem with GNS3. Go to https://gns3.com/community for any other questions or for requesting help with GNS3.
-
-You may also post this issue directly on the GNS3 server repository if you know the bug comes from the server: https://github.com/GNS3/gns3-server/issues/new
-
-**Describe the bug**
-Please provide a clear and detailed description of what the bug is.
-
-**GNS3 version and operating system (please complete the following information):**
- - OS: [e.g. Windows, Linux or macOS]
- - GNS3 version [e.g. 2.1.14]
- - Any use of the GNS3 VM or remote server (ESXi, bare metal etc.)
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1. Go to '...'
-2. Click on '....'
-3. Scroll down to '....'
-4. See error
-
-**Screenshots or videos**
-If applicable, add screenshots (e.g. of the topology and/or error message) or links to videos to help explain the problem. This will help us a lot to quickly find the bug and fix it.
-
-**Additional context**
-Add any other context about the problem here.

.github/ISSUE_TEMPLATE/gns3-development.md

@@ -1,10 +0,0 @@
----
-name: GNS3 development
-about: Any question or discussion regarding GNS3 development
-title: ''
-labels: ''
-assignees: ''
-
----
-
-

.github/ISSUE_TEMPLATE/gns3-feature-request.md

@@ -1,25 +0,0 @@
----
-name: GNS3 feature request
-about: Suggest an idea for GNS3
-title: 'Short description of the feature request'
-labels: Enhancement
-assignees: ''
-
----
-
-**Before you start**
-Please check if a similar feature request has already been submitted.
-
-You may also post this issue directly on the GNS3 server repository if you know the feature request only applies to the server: https://github.com/GNS3/gns3-server/issues/new
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen. If applicable, please provide screenshots
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.github/workflows/add-new-issues-to-project.yml

@@ -1,16 +0,0 @@
-name: Add new issues to GNS3 project
-
-on:
-  issues:
-    types:
-      - opened
-
-jobs:
-  add-to-project:
-    name: Add issue to project
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/add-to-project@v1.0.1
-        with:
-          project-url: https://github.com/orgs/GNS3/projects/3
-          github-token: ${{ secrets.ADD_NEW_ISSUES_TO_PROJECT }}

.github/workflows/codeql.yml

@@ -1,93 +0,0 @@
-# For most projects, this workflow file will not need changing; you simply need
-# to commit it to your repository.
-#
-# You may wish to alter this file to override the set of languages analyzed,
-# or to provide custom queries or build logic.
-#
-# ******** NOTE ********
-# We have attempted to detect the languages in your repository. Please check
-# the `language` matrix defined below to confirm you have the correct set of
-# supported CodeQL languages.
-#
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ "master" ]
-  pull_request:
-    branches: [ "master" ]
-  schedule:
-    - cron: '17 22 * * 6'
-
-jobs:
-  analyze:
-    name: Analyze (${{ matrix.language }})
-    # Runner size impacts CodeQL analysis time. To learn more, please see:
-    #   - https://gh.io/recommended-hardware-resources-for-running-codeql
-    #   - https://gh.io/supported-runners-and-hardware-resources
-    #   - https://gh.io/using-larger-runners (GitHub.com only)
-    # Consider using larger runners or machines with greater resources for possible analysis time improvements.
-    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
-    timeout-minutes: ${{ (matrix.language == 'swift' && 120) || 360 }}
-    permissions:
-      # required for all workflows
-      security-events: write
-
-      # required to fetch internal or private CodeQL packs
-      packages: read
-
-      # only required for workflows in private repositories
-      actions: read
-      contents: read
-
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-        - language: python
-          build-mode: none
-        # CodeQL supports the following values keywords for 'language': 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'swift'
-        # Use `c-cpp` to analyze code written in C, C++ or both
-        # Use 'java-kotlin' to analyze code written in Java, Kotlin or both
-        # Use 'javascript-typescript' to analyze code written in JavaScript, TypeScript or both
-        # To learn more about changing the languages that are analyzed or customizing the build mode for your analysis,
-        # see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning.
-        # If you are analyzing a compiled language, you can modify the 'build-mode' for that language to customize how
-        # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v3
-      with:
-        languages: ${{ matrix.language }}
-        build-mode: ${{ matrix.build-mode }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-
-        # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
-        # queries: security-extended,security-and-quality
-
-    # If the analyze step fails for one of the languages you are analyzing with
-    # "We were unable to automatically build your code", modify the matrix above
-    # to set the build mode to "manual" for that language. Then modify this step
-    # to build your code.
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
-    - if: matrix.build-mode == 'manual'
-      shell: bash
-      run: |
-        echo 'If you are using a "manual" build mode for one or more of the' \
-          'languages you are analyzing, replace this with the commands to build' \
-          'your code, for example:'
-        echo '  make bootstrap'
-        echo '  make release'
-        exit 1
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v3
-      with:
-        category: "/language:${{matrix.language}}"

.github/workflows/testing.yml

@@ -1,19 +0,0 @@
-name: testing
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v5
-    - name: Build and run Docker image
-      run: |
-        docker build -t gns3-gui-test .
-        docker run gns3-gui-test

.gitignore

@@ -60,7 +60,3 @@ keys
 updates
 .cache
 __pycache__
-
-# Virtualenv
-env
-venv

.pyup.yml

@@ -0,0 +1,2 @@
+branch:
+    2.0

.travis.yml

@@ -0,0 +1,19 @@
+sudo: required
+
+services:
+  - docker
+
+notifications:
+  email: false
+  #email:
+  #  - julien@gns3.net
+  #irc:
+  #  channels:
+  #    - "chat.freenode.net#gns3"
+  #  on_success: change
+  #  on_failure: always
+
+script:
+- docker build -t gns3-gui-test .
+- docker run gns3-gui-test 
+

.whitesource

@@ -1,14 +0,0 @@
-{
-  "scanSettings": {
-    "configMode": "AUTO",
-    "configExternalURL": "",
-    "projectToken" : "",
-    "baseBranches": ["master", "2.2", "3.0"]
-  },
-  "checkRunSettings": {
-    "vulnerableCheckRunConclusionLevel": "failure"
-  },
-  "issueSettings": {
-    "minSeverityLevel": "LOW"
-  }
-}

COPYING

@@ -272,6 +272,10 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+License notice for gns3-converter
+---------------------------------
+https://github.com/dlintott/gns3-converter/blob/master/COPYING
+
 License notice for pywin32
 --------------------------
 https://github.com/SublimeText/Pywin32/blob/master/License.txt
@@ -493,12 +497,3 @@ https://github.com/allanlei/python-zipstream/blob/master/LICENSE
 
 Source code is available here:
 https://pypi.python.org/pypi/zipstream
-
-
-Licence notice for aiohttp_cors
--------------------------------
-Copyright 2015 Vladimir Rutsky <vladimir@rutsky.org>.
-
-Licensed under the Apache License, Version 2.0, see LICENSE file for details.
-
-https://github.com/aio-libs/aiohttp_cors

Dockerfile

@@ -1,16 +1,22 @@
 # Run tests inside a container
-FROM ubuntu:latest
+FROM ubuntu:vivid
+
 MAINTAINER GNS3 Team
 
+#ENV DEBIAN_FRONTEND noninteractive
+
 RUN apt-get update
-RUN apt-get install -y --force-yes python3 python3-pyqt6 python3-pip python3-pyqt6.qtsvg python3-pyqt6.qtwebsockets python3-dev xvfb
+RUN apt-get install -y --force-yes python3.4 python3-pyqt5 python3-pip python3-pyqt5.qtsvg python3.4-dev xvfb
 RUN apt-get clean
 
+
 ADD dev-requirements.txt /dev-requirements.txt
 ADD requirements.txt /requirements.txt
-RUN python3 -m pip install --break-system-packages --no-cache-dir -r /dev-requirements.txt
+RUN pip3 install -r /dev-requirements.txt
+
 
 ADD . /src
+
 WORKDIR /src
 
-CMD xvfb-run python3 -m pytest -vv
+CMD xvfb-run python3.4 -m pytest -vv

MANIFEST.in

@@ -1,8 +1,10 @@
-include README.md
+include README.rst
 include AUTHORS
+include INSTALL
 include LICENSE
 include MANIFEST.in
 include requirements.txt
+include tox.ini
 recursive-include tests *
 recursive-include gns3 *
 recursive-include resources *

README.md

@@ -1,62 +0,0 @@
-GNS3-gui
-========
-
-[![image](https://github.com/GNS3/gns3-gui/workflows/testing/badge.svg)](https://github.com/GNS3/gns3-gui/actions?query=workflow%3Atesting)
-
-[![image](https://img.shields.io/pypi/v/gns3-gui.svg)](https://pypi.python.org/pypi/gns3-gui)
-
-[![image](https://snyk.io/test/github/GNS3/gns3-gui/badge.svg)](https://snyk.io/test/github/GNS3/gns3-gui)
-
-GNS3 GUI repository.
-
-Installation
-------------
-
-Please see <https://docs.gns3.com/>
-
-Software dependencies
----------------------
-
-PyQt6 which is either part of the Linux distribution or installable from
-PyPi. The other Python dependencies are automatically installed during
-the GNS3 GUI installation and are listed
-[here](https://github.com/GNS3/gns3-gui/blob/master/requirements.txt)
-
-For connecting to nodes using Telnet, a Telnet client is required. On
-Linux that's a terminal emulator like xterm, gnome-terminal, konsole
-plus the telnet program. For connecting to nodes with a GUI, a VNC
-client is required, optionally a SPICE client can be used for Qemu
-nodes.
-
-For using packet captures within GNS3, Wireshark should be installed.
-It's recommended, but if you don't need that functionality you can go
-without it.
-
-Development
------------
-
-If you want to update the interface, modify the .ui files using QT
-tools. And:
-
-``` {.bash}
-cd scripts
-python build_pyqt.py
-```
-
-### Debug
-
-If you want to see the full logs in the internal shell you can type:
-
-``` {.bash}
-debug 2
-```
-
-Or start the app with --debug flag.
-
-Due to the fact PyQT intercept you can use a web debugger for inspecting
-stuff: <https://github.com/Kozea/wdb>
-
-Security issues
----------------
-
-Please contact us at <security@gns3.net>

README.rst

@@ -0,0 +1,42 @@
+GNS3-gui
+========
+
+.. image:: https://travis-ci.org/GNS3/gns3-gui.svg?branch=master
+    :target: https://travis-ci.org/GNS3/gns3-gui
+
+.. image:: https://img.shields.io/pypi/v/gns3-gui.svg
+    :target: https://pypi.python.org/pypi/gns3-gui
+
+
+GNS3 GUI repository.
+
+Installation
+------------
+
+https://gns3.com/support/docs
+
+Development
+-------------
+
+If you want to update the interface, modify the .ui files using QT tools. And:
+
+.. code:: bash
+
+    cd scripts
+    python build_pyqt.py
+
+Debug
+"""""
+
+If you want to see the full logs in the internal shell you can type:
+
+.. code:: bash
+    
+    debug 2
+
+
+Or start the app with --debug flag.
+
+Due to the fact PyQT intercept you can use a web debugger for inspecting stuff:
+https://github.com/Kozea/wdb
+

SECURITY.md

@@ -1,5 +0,0 @@
-# Security Policy
-
-## Reporting a Vulnerability
-
-Please use GitHub's report a vulnerability feature. More information can be found in https://docs.github.com/en/code-security/security-advisories/guidance-on-reporting-and-writing/privately-reporting-a-security-vulnerability

dev-requirements.txt

@@ -1,5 +1,7 @@
 -rrequirements.txt
 
-pytest==8.4.2; python_version == '3.9'  # version 8.4.2 is the last one supporting Python 3.9
-pytest==9.0.2; python_version >= '3.10'
-pytest-timeout==2.4.0
+pep8
+pytest
+pytest-pythonpath # useful for running tests outside tox
+pytest-timeout
+pytest-capturelog

fake_frozen_gns3.py

@@ -33,8 +33,6 @@ sys.path.insert(0, os.path.dirname(sys.executable))
 sys.path.insert(0, os.path.join(os.path.dirname(sys.executable), 'site-packages'))
 
 sys.frozen = True
-sys.executable = "/Applications/GNS3.app/Contents/MacOS/gns3"
-os.environ["_"] = "/Applications/GNS3.app/Contents/MacOS/gns3"
 
 module = importlib.import_module("gns3.main")
 module.main()

gns3/appliance_manager.py

@@ -1,93 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright (C) 2016 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/>.
-
-from .qt import QtCore
-from .controller import Controller
-from .local_config import LocalConfig
-from .settings import GENERAL_SETTINGS
-
-
-import logging
-log = logging.getLogger(__name__)
-
-
-class ApplianceManager(QtCore.QObject):
-    """
-    Manager for appliances.
-    """
-
-    appliances_changed_signal = QtCore.Signal()
-
-    def __init__(self):
-
-        super().__init__()
-        self._appliances = []
-        self._controller = Controller.instance()
-        self._controller.connected_signal.connect(self.refresh)
-        self._controller.disconnected_signal.connect(self._controllerDisconnectedSlot)
-
-    def refresh(self, update=False):
-        """
-        Gets the appliances from the controller.
-        """
-
-        if self._controller.connected():
-            settings = LocalConfig.instance().loadSectionSettings("MainWindow", GENERAL_SETTINGS)
-            symbol_theme = settings["symbol_theme"]
-            if update is True:
-                self._controller.get("/appliances?update=yes&symbol_theme={}".format(symbol_theme), self._listAppliancesCallback, progressText="Downloading appliances from online registry...")
-            else:
-                self._controller.get("/appliances?symbol_theme={}".format(symbol_theme), self._listAppliancesCallback)
-
-    def _controllerDisconnectedSlot(self):
-        """
-        Called when the controller has been disconnected.
-        """
-
-        self._appliances = []
-        self.appliances_changed_signal.emit()
-
-    def appliances(self):
-        """
-        Returns the appliances.
-
-        :returns: array of appliances
-        """
-
-        return self._appliances
-
-    def _listAppliancesCallback(self, result, error=False, **kwargs):
-        """
-        Callback to get the appliances.
-        """
-
-        if error is True:
-            log.error("Error while getting appliances list: {}".format(result.get("message", "unknown")))
-            return
-        self._appliances = result
-        self.appliances_changed_signal.emit()
-
-    @staticmethod
-    def instance():
-        """
-        Singleton to return only on instance of ApplianceManager.
-        :returns: instance of ApplianceManager
-        """
-
-        if not hasattr(ApplianceManager, '_instance') or ApplianceManager._instance is None:
-            ApplianceManager._instance = ApplianceManager()
-        return ApplianceManager._instance

gns3/application.py

@@ -27,15 +27,18 @@ log = logging.getLogger(__name__)
 
 
 class Application(QtWidgets.QApplication):
-    file_open_signal = QtCore.Signal(str)
+    file_open_signal = QtCore.pyqtSignal(str)
 
     def __init__(self, argv):
 
         self.setStyle(QtWidgets.QStyleFactory.create("Fusion"))
-        super().__init__(argv)
+        # both Qt and PyQt must be version >= 5.6 in order to enable high DPI scaling
+        if parse_version(QtCore.QT_VERSION_STR) >= parse_version("5.6") and parse_version(QtCore.PYQT_VERSION_STR) >= parse_version("5.6"):
+            # only available starting Qt version 5.6
+            self.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling)
+            self.setAttribute(QtCore.Qt.AA_UseHighDpiPixmaps)
 
-        # this is tell Wayland what is the name of the desktop file (gns3.desktop)
-        self.setDesktopFileName("gns3")
+        super().__init__(argv)
 
         # this info is necessary for QSettings
         self.setOrganizationName("GNS3")
@@ -48,7 +51,7 @@ class Application(QtWidgets.QApplication):
         self.open_file_at_startup = None
 
     def event(self, event):
-        # When you double click on a file, you receive an event
+        # When you double click file you receive an event
         # and not the file as command line parameter
         if sys.platform.startswith("darwin"):
             if isinstance(event, QtGui.QFileOpenEvent):

gns3/base_node.py

@@ -1,342 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2014 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/>.
-
-"""
-Base class for node classes.
-"""
-
-from .qt import QtCore
-from .ports.port import Port
-
-import logging
-log = logging.getLogger(__name__)
-
-
-class BaseNode(QtCore.QObject):
-    """
-    BaseNode implementation.
-
-    :param module: Module instance
-    :param server: client connection to a server
-    :param project: Project instance
-    """
-
-    # signals used to let the GUI know about some events.
-    created_signal = QtCore.Signal(int)
-    started_signal = QtCore.Signal()
-    stopped_signal = QtCore.Signal()
-    suspended_signal = QtCore.Signal()
-    updated_signal = QtCore.Signal()
-    loaded_signal = QtCore.Signal()
-    deleted_signal = QtCore.Signal()
-    error_signal = QtCore.Signal(int, str)
-    server_error_signal = QtCore.Signal(int, str)
-
-    _instance_count = 1
-
-    # node statuses
-    stopped = 0
-    started = 1
-    suspended = 2
-
-    # node categories
-    routers = "router"
-    switches = "switch"
-    end_devices = "guest"
-    security_devices = "firewall"
-
-    def __init__(self, module, compute, project):
-
-        super().__init__()
-
-        # create an unique ID
-        self._id = BaseNode._instance_count
-        BaseNode._instance_count += 1
-
-        self._module = module
-        self._compute = compute
-        assert project is not None
-        self._project = project
-        self._initialized = False
-        self._loading = False
-        self._status = BaseNode.stopped
-        self._ports = []
-        self._links = set()
-
-    def links(self):
-        """
-        Links connected to this node
-        """
-
-        return self._links
-
-    def addLink(self, link):
-        """
-        Add a link connected to this node
-
-        :param link: link object
-        """
-
-        self._links.add(link)
-
-    def deleteLink(self, link):
-        """
-        Delete a link connected to this node
-
-        :param link: link object
-        """
-
-        try:
-            self._links.remove(link)
-        except KeyError:
-            pass
-
-    def state(self):
-        """
-        Returns a human readable status of this node.
-
-        :returns: string
-        """
-
-        status = self.status()
-        if status == self.started:
-            return "started"
-        elif status == self.stopped:
-            return "stopped"
-        elif status == self.suspended:
-            return "suspended"
-        return "unknown"
-
-    @classmethod
-    def reset(cls):
-        """
-        Reset the instance count.
-        """
-
-        cls._instance_count = 1
-
-    def module(self):
-        """
-        Returns this node module.
-
-        :returns: Module instance
-        """
-
-        return self._module
-
-    def compute(self):
-        """
-        Returns this node compute.
-
-        :returns: Compute instance
-        """
-        return self._compute
-
-    def project(self):
-        """
-        Returns this node project.
-
-        :returns: Project instance
-        """
-
-        return self._project
-
-    def id(self):
-        """
-        Returns this node identifier.
-
-        :returns: node identifier (integer)
-        """
-
-        return self._id
-
-    def setId(self, new_id):
-        """
-        Sets an identifier for this node.
-
-        :param new_id: node identifier (integer)
-        """
-
-        self._id = new_id
-
-        # update the instance count to avoid conflicts
-        if new_id >= BaseNode._instance_count:
-            BaseNode._instance_count = new_id + 1
-
-    def status(self):
-        """
-        Returns the status of this node.
-        0 = stopped, 1 = started, 2 = suspended.
-
-        :returns: node status (integer)
-        """
-
-        return self._status
-
-    def setStatus(self, status):
-        """
-        Sets a status for this node.
-        0 = stopped, 1 = started, 2 = suspended.
-
-        :param status: node status (integer)
-        """
-
-        if status == self._status:
-            return
-        self._status = status
-        if status == self.started:
-            for port in self._ports:
-                # set ports as started
-                port.setStatus(Port.started)
-            self.started_signal.emit()
-        elif status == self.stopped:
-            for port in self._ports:
-                # set ports as stopped
-                port.setStatus(Port.stopped)
-            self.stopped_signal.emit()
-        elif status == self.suspended:
-            for port in self._ports:
-                # set ports as suspended
-                port.setStatus(Port.suspended)
-            self.suspended_signal.emit()
-
-    def initialized(self):
-        """
-        Returns if the node has been initialized
-
-        :returns: boolean
-        """
-
-        return self._initialized
-
-    def setInitialized(self, initialized):
-        """
-        Sets if the node has been initialized
-
-        :param initialized: boolean
-        """
-
-        self._initialized = initialized
-
-    def update(self, new_settings):
-        """
-        Updates the settings for this node.
-        Must be overloaded.
-
-        :param new_settings: settings dictionary
-        """
-
-        raise NotImplementedError()
-
-    def ports(self):
-        """
-        Returns all the ports for this node.
-
-        :returns: list of Port instances
-        """
-
-        return self._ports
-
-    def controllerHttpPost(self, path, callback, body=None, context=None, **kwargs):
-        """
-        POST on current server / project
-
-        :param path: Remote path
-        :param callback: callback method to call when the server replies
-        :param body: params to send (dictionary)
-        :param context: Pass a context to the response callback
-        """
-
-        self._project.post(path, callback, body=body, context=context, **kwargs)
-
-    def controllerHttpPut(self, path, callback, body=None, context=None, **kwargs):
-        """
-        PUT on current server / project
-
-        :param path: Remote path
-        :param callback: callback method to call when the server replies
-        :param body: params to send (dictionary)
-        :param context: Pass a context to the response callback
-        """
-
-        self._project.put(path, callback, body=body, context=context, **kwargs)
-
-    def controllerHttpGet(self, path, callback, context=None, **kwargs):
-        """
-        Get on current server / project
-
-        :param path: Remote path
-        :param callback: callback method to call when the server replies
-        :param body: params to send (dictionary)
-        :param context: Pass a context to the response callback
-        """
-
-        self._project.get(path, callback, context=context, **kwargs)
-
-    def controllerHttpDelete(self, path, callback, context=None, **kwargs):
-        """
-        Delete on current server / project
-
-        :param path: Remote path
-        :param callback: callback method to call when the server replies
-        :param context: Pass a context to the response callback
-        """
-
-        self._project.delete(path, callback, context=context, **kwargs)
-
-    @staticmethod
-    def defaultCategories():
-        """
-        Returns the default categories.
-
-        :returns: dict
-        """
-
-        categories = {"Routers": BaseNode.routers,
-                      "Switches": BaseNode.switches,
-                      "End devices": BaseNode.end_devices,
-                      "Security devices": BaseNode.security_devices}
-
-        return categories
-
-    @staticmethod
-    def defaultSymbol():
-        """
-        Returns the default symbol path for this node.
-        Must be overloaded.
-
-        :returns: symbol path (or resource).
-        """
-
-        raise NotImplementedError()
-
-    @staticmethod
-    def categories(self):
-        """
-        Returns the node categories the node is part of (used by the device panel).
-
-        :returns: list of node category (integer)
-        """
-
-        raise NotImplementedError()
-
-    def __str__(self):
-        """
-        Must be overloaded.
-        """
-
-        raise NotImplementedError()

gns3/compute.py

@@ -1,247 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright (C) 2016 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 uuid
-
-
-class Compute:
-    """
-    An instance of a compute.
-    """
-
-    def __init__(self, compute_id=None):
-
-        if compute_id is None:
-            compute_id = str(uuid.uuid4())
-        self._compute_id = compute_id
-        self._name = compute_id
-        self._connected = False
-        self._protocol = "http"
-        self._host = None
-        self._port = 3080
-        self._user = None
-        self._password = None
-        self._cpu_usage_percent = None
-        self._memory_usage_percent = None
-        self._capabilities = {"node_types": []}
-        self._last_error = None
-
-    def id(self):
-        """
-        Returns the compute ID.
-
-        :returns: compute identifier
-        """
-
-        return self._compute_id
-
-    def name(self):
-        """
-        Returns the compute name.
-
-        :returns: compute name
-        """
-
-        return self._name
-
-    def setName(self, name):
-        """
-        Sets the compute name.
-
-        :param name: compute name
-        """
-
-        self._name = name
-
-    def connected(self):
-        """
-        Returns whether or not there is a connection to the compute.
-
-        :returns: boolean
-        """
-
-        return self._connected
-
-    def setConnected(self, value):
-        """
-        Sets whether or not there is a connection to the compute.
-
-        :param value: boolean
-        """
-
-        self._connected = value
-
-    def host(self):
-        """
-        Returns the compute host.
-
-        :returns: host (string)
-        """
-
-        return self._host
-
-    def setHost(self, host):
-        """
-        Sets the compute host.
-
-        :param host: host (string)
-        """
-
-        self._host = host
-
-    def port(self):
-        """
-        Returns the compute port number.
-
-        :returns: port number (integer)
-        """
-
-        return self._port
-
-    def setPort(self, port):
-        """
-        Sets the compute port number.
-
-        :param port: port number (integer)
-        """
-
-        self._port = port
-
-    def user(self):
-        """
-        Returns the compute user for HTTP authentication.
-
-        :returns: user (string)
-        """
-
-        return self._user
-
-    def setUser(self, user):
-        """
-        Sets the compute user for HTTP authentication.
-
-        :param user: user (string)
-        """
-
-        self._user = user
-
-    def setPassword(self, password):
-        """
-        Returns the compute password for HTTP authentication.
-
-        :returns: password (string)
-        """
-
-        self._password = password
-
-    def protocol(self):
-        """
-        Returns the compute protocol.
-
-        :returns: protocol (string)
-        """
-
-        return self._protocol
-
-    def setProtocol(self, protocol):
-        """
-        Sets the compute protocol.
-
-        :param protocol: protocol (string)
-        """
-
-        self._protocol = protocol
-
-    def cpuUsagePercent(self):
-        """
-        Returns the compute CPU usage.
-
-        :returns: CPU usage (integer)
-        """
-
-        return self._cpu_usage_percent
-
-    def setCpuUsagePercent(self, usage):
-        """
-        Sets the compute CPU usage.
-
-        :param usage: CPU usage (integer)
-        """
-
-        self._cpu_usage_percent = usage
-
-    def setMemoryUsagePercent(self, usage):
-        """
-        Returns the compute memory usage.
-
-        :returns: memory usage (integer)
-        """
-
-        self._memory_usage_percent = usage
-
-    def memoryUsagePercent(self):
-        """
-        Sets the compute memory usage.
-
-        :param usage: memory usage (integer)
-        """
-
-        return self._memory_usage_percent
-
-    def capabilities(self):
-        """
-        Returns the compute capabilities
-
-        :returns: capabilities (dictionary)
-        """
-
-        return self._capabilities
-
-    def setCapabilities(self, value):
-        """
-        Sets the compute capabilities
-
-        :param value: capabilities (dictionary)
-        """
-
-        self._capabilities = value
-
-    def setLastError(self, last_error):
-        self._last_error = last_error
-
-    def lastError(self):
-        return self._last_error
-
-    def __str__(self):
-
-        return self._compute_id
-
-    def __json__(self):
-
-        return {"host": self._host,
-                "port": self._port,
-                "protocol": self._protocol,
-                "user": self._user,
-                "password": self._password,
-                "name": self._name,
-                "compute_id": self._compute_id}
-
-    def __eq__(self, v):
-
-        if isinstance(v, Compute):
-            return self.__json__() == v.__json__()
-        return False

gns3/compute_manager.py

@@ -1,265 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright (C) 2016 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/>.
-
-from .qt import QtCore
-from .compute import Compute
-from .controller import Controller
-
-import sys
-import copy
-import urllib
-import datetime
-
-
-import logging
-log = logging.getLogger(__name__)
-
-
-class ComputeManager(QtCore.QObject):
-    """
-    Manager for computes.
-    """
-
-    created_signal = QtCore.Signal(str)
-    updated_signal = QtCore.Signal(str)
-    deleted_signal = QtCore.Signal(str)
-
-    def __init__(self):
-
-        super().__init__()
-        self._computes = {}
-        self._controller = Controller.instance()
-        self._controller.connected_signal.connect(self._controllerConnectedSlot)
-        self._controller.disconnected_signal.connect(self._controllerDisconnectedSlot)
-        self._controllerConnectedSlot()
-
-        # No need to refresh via an API call if we received fresh data from the notification feed
-        self._last_computes_refresh = datetime.datetime.now().timestamp()
-
-        self._timer = QtCore.QTimer()
-        self._timer.setInterval(1000)
-        self._refreshingComputes = False
-        self._timer.timeout.connect(self._refreshComputesSlot)
-        self._timer.start()
-
-    def _refreshComputesSlot(self):
-        """
-        Called when computes are refreshed.
-        """
-
-        if self._refreshingComputes:
-            return
-        if self._controller.connected() and datetime.datetime.now().timestamp() - self._last_computes_refresh > 1:
-            self._last_computes_refresh = datetime.datetime.now().timestamp()
-            self._refreshingComputes = True
-            self._controller.get("/computes", self._listComputesCallback, showProgress=False, timeout=30)
-
-    def _controllerConnectedSlot(self):
-        """
-        Called when connected to a compute.
-        """
-
-        if self._controller.connected():
-            self._refreshingComputes = True
-            self._controller.get("/computes", self._listComputesCallback, showProgress=False, timeout=30)
-
-    def _controllerDisconnectedSlot(self):
-        """
-        Called when disconnected from a compute.
-        """
-
-        for compute_id in list(self._computes):
-            del self._computes[compute_id]
-            self.deleted_signal.emit(compute_id)
-
-    def _listComputesCallback(self, result, error=False, **kwargs):
-        """
-        Callback to list computes.
-        """
-
-        self._refreshingComputes = False
-        if error is True:
-            log.error("Error while getting compute list: {}".format(result["message"]))
-            return
-
-        for compute in result:
-            self.computeDataReceivedCallback(compute)
-
-    def computeDataReceivedCallback(self, compute):
-        """
-        Called when we received data from a compute node.
-        """
-
-        self._last_computes_refresh = datetime.datetime.now().timestamp()
-
-        new_node = False
-        compute_id = compute["compute_id"]
-        if compute_id not in self._computes:
-            new_node = True
-            self._computes[compute_id] = Compute(compute_id)
-
-        self._computes[compute_id].setName(compute["name"])
-        self._computes[compute_id].setConnected(compute["connected"])
-        self._computes[compute_id].setProtocol(compute["protocol"])
-        self._computes[compute_id].setHost(compute["host"])
-        self._computes[compute_id].setPort(compute["port"])
-        self._computes[compute_id].setUser(compute["user"])
-        self._computes[compute_id].setCpuUsagePercent(compute["cpu_usage_percent"])
-        self._computes[compute_id].setMemoryUsagePercent(compute["memory_usage_percent"])
-        self._computes[compute_id].setCapabilities(compute["capabilities"])
-        self._computes[compute_id].setLastError(compute.get("last_error"))
-
-        if new_node:
-            self.created_signal.emit(compute_id)
-        else:
-            self.updated_signal.emit(compute_id)
-
-    def computeIsTheRemoteGNS3VM(self, compute):
-        """
-        :returns: boolean True if the remote server is the remote GNS3 VM
-        """
-
-        if compute.id() != "local" and compute.id() != "vm":
-            if self.vmCompute() and "GNS3 VM ({})".format(compute.name()) == self.vmCompute().name():
-                return True
-        return False
-
-    def computes(self):
-        """
-        :returns: List of computes nodes
-        """
-
-        computes = []
-        for compute in self._computes.values():
-            # We filter the remote GNS3 VM compute from the computes list
-            if not self.computeIsTheRemoteGNS3VM(compute):
-                computes.append(compute)
-        return computes
-
-    def vmCompute(self):
-        """
-        :returns: The GNS3 VM compute node or None
-        """
-
-        try:
-            return self._computes["vm"]
-        except KeyError:
-            return None
-
-    def localCompute(self):
-        """
-        :returns: The local compute node or None
-        """
-
-        try:
-            return self._computes["local"]
-        except KeyError:
-            return None
-
-    def localPlatform(self):
-        """
-        Return the platform of the local compute.
-
-        With a remote controller it could be different of our local platform
-        """
-
-        c = self.localCompute()
-        if c is None:
-            return sys.platform
-        return c.capabilities().get("platform", sys.platform)
-
-    def remoteComputes(self):
-        """
-        :returns: List of non local and non VM computes
-        """
-
-        return [c for c in self._computes.values() if c.id() != "local" and c.id() != "vm"]
-
-    def getCompute(self, compute_id):
-        """
-        Gets a compute by ID
-
-        :param compute_id: compute identifier
-        :returns: compute
-        """
-
-        if compute_id.startswith("http:") or compute_id.startswith("https:"):
-            u = urllib.parse.urlsplit(compute_id)
-            for compute in self._computes.values():
-                if "{}:{}".format(compute.host(), compute.port()) == u.netloc:
-                    return compute
-            raise KeyError("Compute ID {} is missing.".format(compute_id))
-        if compute_id not in self._computes:
-            self._computes[compute_id] = Compute(compute_id)
-            self.created_signal.emit(compute_id)
-        return self._computes[compute_id]
-
-    def deleteCompute(self, compute_id):
-        """
-        Deletes a compute by ID
-
-        :param compute_id: compute identifier
-        """
-
-        if compute_id in self._computes:
-            del self._computes[compute_id]
-            self._controller.delete("/computes/{compute_id}".format(compute_id=compute_id), None)
-            self.deleted_signal.emit(compute_id)
-
-    def updateList(self, computes):
-        """
-        Sync an array of compute with remote
-        """
-
-        for compute_id in copy.copy(self._computes):
-            # Delete compute on controller not in the new computes
-            if compute_id in ["local", "vm"]:
-                continue
-
-            if compute_id not in [c.id() for c in computes]:
-                log.debug("Delete compute %s", compute_id)
-                self.deleteCompute(compute_id)
-            else:
-                # Update the changed nodes
-                for c in computes:
-                    if c.id() == compute_id and c != self._computes[compute_id]:
-                        log.debug("Update compute %s", compute_id)
-                        self._controller.put("/computes/" + compute_id, None, body=c.__json__())
-                        self._computes[compute_id] = c
-                        self.updated_signal.emit(compute_id)
-        # Create the new nodes
-        for compute in computes:
-            if compute.id() not in self._computes:
-                log.debug("Create compute %s", compute.id())
-                self._controller.post("/computes", None, body=compute.__json__())
-                self._computes[compute.id()] = compute
-                self.created_signal.emit(compute.id())
-
-    @staticmethod
-    def reset():
-        ComputeManager._instance = None
-
-    @staticmethod
-    def instance():
-        """
-        Singleton to return only on instance of ComputeManager.
-        :returns: instance of ComputeManager
-        """
-
-        if not hasattr(ComputeManager, '_instance') or ComputeManager._instance is None:
-            ComputeManager._instance = ComputeManager()
-        return ComputeManager._instance

gns3/compute_summary_view.py

@@ -1,159 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2014 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/>.
-
-"""
-Compute summary view that list all the compute, their status.
-"""
-
-from .qt import QtGui, QtCore, QtWidgets
-from .compute_manager import ComputeManager
-from .topology import Topology
-from .node import Node
-
-import logging
-log = logging.getLogger(__name__)
-
-
-class ComputeItem(QtWidgets.QTreeWidgetItem):
-    """
-    Custom item for the QTreeWidget instance
-    (topology summary view).
-
-    :param parent: parent widget
-    :param compute: Compute instance
-    """
-
-    def __init__(self, parent, compute):
-
-        super().__init__(parent)
-        self._compute = compute
-        self._parent = parent
-        self._status = "unknown"
-
-        self._refreshStatusSlot()
-
-    def _refreshStatusSlot(self):
-        """
-        Changes the icon to show the node status (started, stopped etc.)
-        """
-
-        if self is None:
-            return
-
-        usage = None
-        text = self._compute.name()
-
-        if self._compute.cpuUsagePercent() is not None:
-            text = "{} CPU {}%, RAM {}%".format(text, self._compute.cpuUsagePercent(), self._compute.memoryUsagePercent())
-
-        self.setText(0, text)
-        if self._compute.connected():
-            self._status = "connected"
-            self.setToolTip(0, "Server {} version {} running on {}".format(self._compute.name(),
-                                                                           self._compute.capabilities().get("version", "n/a"),
-                                                                           self._compute.capabilities().get("platform", "")))
-            if usage is None or (self._compute.cpuUsagePercent() < 90 and self._compute.memoryUsagePercent() < 90):
-                self.setIcon(0, QtGui.QIcon(':/icons/led_green.svg'))
-            else:
-                self.setIcon(0, QtGui.QIcon(':/icons/led_yellow.svg'))
-        else:
-            last_error = self._compute.lastError()
-            if last_error:
-                self.setToolTip(0, "Failed to connect to {}: {}".format(self._compute.name(), last_error))
-                self.setIcon(0, QtGui.QIcon(':/icons/led_red.svg'))
-            elif self._status == "unknown":
-                self.setToolTip(0, "Discovering or connecting to {}...".format(self._compute.name()))
-                self.setIcon(0, QtGui.QIcon(':/icons/led_gray.svg'))
-            else:
-                self._status = "stopped"
-                self.setToolTip(0, "{} is stopped or cannot be reached".format(self._compute.name()))
-                self.setIcon(0, QtGui.QIcon(':/icons/led_red.svg'))
-        self._parent.sortItems(0, QtCore.Qt.SortOrder.AscendingOrder)
-
-        # add nodes belonging to this compute
-        self.takeChildren()
-        nodes = Topology.instance().nodes()
-        for node in nodes:
-            if node.compute().id() == self._compute.id():
-                item = QtWidgets.QTreeWidgetItem()
-                item.setText(0, node.name())
-                if node.status() == Node.started:
-                    item.setIcon(0, QtGui.QIcon(':/icons/led_green.svg'))
-                elif node.status() == Node.suspended:
-                    item.setIcon(0, QtGui.QIcon(':/icons/led_yellow.svg'))
-                else:
-                    item.setIcon(0, QtGui.QIcon(':/icons/led_red.svg'))
-                self.addChild(item)
-        self.sortChildren(0, QtCore.Qt.SortOrder.AscendingOrder)
-
-
-class ComputeSummaryView(QtWidgets.QTreeWidget):
-    """
-    Compute summary view implementation.
-
-    :param parent: parent widget
-    """
-
-    def __init__(self, parent):
-
-        super().__init__(parent)
-        self._computes = {}
-        ComputeManager.instance().created_signal.connect(self._computeAddedSlot)
-        ComputeManager.instance().updated_signal.connect(self._computeUpdatedSlot)
-        ComputeManager.instance().deleted_signal.connect(self._computeRemovedSlot)
-        for compute in ComputeManager.instance().computes():
-            self._computeAddedSlot(compute.id())
-
-    def _computeAddedSlot(self, compute_id):
-        """
-        Called when a compute is added to the list of computes
-
-        :params url: URL of the compute
-        """
-
-        compute = ComputeManager.instance().getCompute(compute_id)
-        if ComputeManager.instance().computeIsTheRemoteGNS3VM(compute):
-            return
-        self._computes[compute_id] = ComputeItem(self, compute)
-
-    def _computeUpdatedSlot(self, compute_id):
-        """
-        Called when a compute is updated
-
-        :params url: URL of the compute
-        """
-
-        if compute_id in self._computes:
-            compute = ComputeManager.instance().getCompute(compute_id)
-            # We hide the remote GNS3 VM
-            if ComputeManager.instance().computeIsTheRemoteGNS3VM(compute):
-                self._computeRemovedSlot(compute_id)
-            else:
-                self._computes[compute_id]._refreshStatusSlot()
-        else:
-            self._computeAddedSlot(compute_id)
-
-    def _computeRemovedSlot(self, compute_id):
-        """
-        Called when a compute is removed to the list of computes
-
-        :params url: URL of the compute
-        """
-
-        if compute_id in self._computes:
-            self.takeTopLevelItem(self.indexOfTopLevelItem(self._computes[compute_id]))
-            del self._computes[compute_id]

gns3/configs/ios_base_startup-config.txt

@@ -0,0 +1,26 @@
+!
+service timestamps debug datetime msec
+service timestamps log datetime msec
+no service password-encryption
+!
+hostname %h
+!
+ip cef
+no ip domain-lookup
+no ip icmp rate-limit unreachable
+ip tcp synwait 5
+no cdp log mismatch duplex
+!
+line con 0
+ exec-timeout 0 0
+ logging synchronous
+ privilege level 15
+ no login
+line aux 0
+ exec-timeout 0 0
+ logging synchronous
+ privilege level 15
+ no login
+!
+!
+end

gns3/configs/ios_etherswitch_startup-config.txt

@@ -0,0 +1,181 @@
+!
+service timestamps debug datetime msec
+service timestamps log datetime msec
+no service password-encryption
+no service dhcp
+!
+hostname %h
+!
+ip cef
+no ip routing
+no ip domain-lookup
+no ip icmp rate-limit unreachable
+ip tcp synwait 5
+no cdp log mismatch duplex
+vtp file nvram:vlan.dat
+!
+!
+interface FastEthernet0/0
+ description *** Unused for Layer2 EtherSwitch ***
+ no ip address
+ shutdown
+!
+interface FastEthernet0/1
+ description *** Unused for Layer2 EtherSwitch ***
+ no ip address
+ shutdown
+!
+interface FastEthernet1/0
+ no shutdown
+ duplex full
+ speed 100
+!
+interface FastEthernet1/1
+ no shutdown
+ duplex full
+ speed 100
+!
+interface FastEthernet1/2
+ no shutdown
+ duplex full
+ speed 100
+!
+interface FastEthernet1/3
+ no shutdown
+ duplex full
+ speed 100
+!
+interface FastEthernet1/4
+ no shutdown
+ duplex full
+ speed 100
+!
+interface FastEthernet1/5
+ no shutdown
+ duplex full
+ speed 100
+!
+interface FastEthernet1/6
+ no shutdown
+ duplex full
+ speed 100
+!
+interface FastEthernet1/7
+ no shutdown
+ duplex full
+ speed 100
+!
+interface FastEthernet1/8
+ no shutdown
+ duplex full
+ speed 100
+!
+interface FastEthernet1/9
+ no shutdown
+ duplex full
+ speed 100
+!
+interface FastEthernet1/10
+ no shutdown
+ duplex full
+ speed 100
+!
+interface FastEthernet1/11
+ no shutdown
+ duplex full
+ speed 100
+!
+interface FastEthernet1/12
+ no shutdown
+ duplex full
+ speed 100
+!
+interface FastEthernet1/13
+ no shutdown
+ duplex full
+ speed 100
+!
+interface FastEthernet1/14
+ no shutdown
+ duplex full
+ speed 100
+!
+interface FastEthernet1/15
+ no shutdown
+ duplex full
+ speed 100
+!
+interface Vlan1
+ no ip address
+ shutdown
+!
+!
+line con 0
+ exec-timeout 0 0
+ logging synchronous
+ privilege level 15
+ no login
+line aux 0
+ exec-timeout 0 0
+ logging synchronous
+ privilege level 15
+ no login
+!
+!
+banner exec $
+
+***************************************************************
+This is a normal Router with a SW module inside (NM-16ESW)
+It has been preconfigured with hard coded speed and duplex
+
+To create vlans use the command "vlan database" from exec mode
+After creating all desired vlans use "exit" to apply the config
+
+To view existing vlans use the command "show vlan-switch brief"
+
+Warning: You are using an old IOS image for this router.
+Please update the IOS to enable the "macro" command!
+***************************************************************
+
+$
+!
+!Warning: If the IOS is old and doesn't support macro, it will stop the configuration loading from this point!
+!
+macro name add_vlan
+end
+vlan database
+vlan $v
+exit
+@
+macro name del_vlan
+end
+vlan database
+no vlan $v
+exit
+@
+!
+!
+banner exec $
+
+***************************************************************
+This is a normal Router with a Switch module inside (NM-16ESW)
+It has been pre-configured with hard-coded speed and duplex
+
+To create vlans use the command "vlan database" in exec mode
+After creating all desired vlans use "exit" to apply the config
+
+To view existing vlans use the command "show vlan-switch brief"
+
+Alias(exec)     : vl   - "show vlan-switch brief" command
+Alias(configure): va X - macro to add vlan X
+Alias(configure): vd X - macro to delete vlan X
+***************************************************************
+
+$
+!
+alias configure va macro global trace add_vlan $v
+alias configure vd macro global trace del_vlan $v
+alias exec vl show vlan-switch brief
+!
+!
+end

gns3/configs/iou_l2_base_startup-config.txt

@@ -0,0 +1,132 @@
+!
+service timestamps debug datetime msec
+service timestamps log datetime msec
+no service password-encryption
+!
+hostname %h
+!
+!
+!
+logging discriminator EXCESS severity drops 6 msg-body drops EXCESSCOLL 
+logging buffered 50000
+logging console discriminator EXCESS
+!
+no ip icmp rate-limit unreachable
+!
+ip cef
+no ip domain-lookup
+!
+!
+!
+!
+!
+!
+ip tcp synwait-time 5
+! 
+!
+!
+!
+!
+!
+interface Ethernet0/0
+ no ip address
+ no shutdown
+ duplex auto
+!
+interface Ethernet0/1
+ no ip address
+ no shutdown
+ duplex auto
+!
+interface Ethernet0/2
+ no ip address
+ no shutdown
+ duplex auto
+!
+interface Ethernet0/3
+ no ip address
+ no shutdown
+ duplex auto
+!
+interface Ethernet1/0
+ no ip address
+ no shutdown
+ duplex auto
+!
+interface Ethernet1/1
+ no ip address
+ no shutdown
+ duplex auto
+!
+interface Ethernet1/2
+ no ip address
+ no shutdown
+ duplex auto
+!
+interface Ethernet1/3
+ no ip address
+ no shutdown
+ duplex auto
+!
+interface Ethernet2/0
+ no ip address
+ no shutdown
+ duplex auto
+!
+interface Ethernet2/1
+ no ip address
+ no shutdown
+ duplex auto
+!
+interface Ethernet2/2
+ no ip address
+ no shutdown
+ duplex auto
+!
+interface Ethernet2/3
+ no ip address
+ no shutdown
+ duplex auto
+!
+interface Ethernet3/0
+ no ip address
+ no shutdown
+ duplex auto
+!
+interface Ethernet3/1
+ no ip address
+ no shutdown
+ duplex auto
+!
+interface Ethernet3/2
+ no ip address
+ no shutdown
+ duplex auto
+!
+interface Ethernet3/3
+ no ip address
+ no shutdown
+ duplex auto
+!
+interface Vlan1
+ no ip address
+ shutdown
+!
+!
+!
+!
+!
+!
+!
+!
+!
+line con 0
+ exec-timeout 0 0
+ privilege level 15
+ logging synchronous
+line aux 0
+ exec-timeout 0 0
+ privilege level 15
+ logging synchronous
+!
+end

gns3/configs/iou_l3_base_startup-config.txt

@@ -0,0 +1,108 @@
+!
+service timestamps debug datetime msec
+service timestamps log datetime msec
+no service password-encryption
+!
+hostname %h
+!
+!
+!
+no ip icmp rate-limit unreachable
+!
+!         
+!
+!
+ip cef
+no ip domain-lookup
+!
+!
+ip tcp synwait-time 5
+!
+!
+!
+!
+interface Ethernet0/0
+ no ip address
+ shutdown
+!
+interface Ethernet0/1
+ no ip address
+ shutdown
+!
+interface Ethernet0/2
+ no ip address
+ shutdown 
+!
+interface Ethernet0/3
+ no ip address
+ shutdown
+!
+interface Ethernet1/0
+ no ip address
+ shutdown
+!
+interface Ethernet1/1
+ no ip address
+ shutdown
+!
+interface Ethernet1/2
+ no ip address
+ shutdown
+!
+interface Ethernet1/3
+ no ip address
+ shutdown
+!
+interface Serial2/0
+ no ip address
+ shutdown
+ serial restart-delay 0
+!
+interface Serial2/1
+ no ip address
+ shutdown
+ serial restart-delay 0
+!
+interface Serial2/2
+ no ip address
+ shutdown
+ serial restart-delay 0
+!
+interface Serial2/3
+ no ip address
+ shutdown
+ serial restart-delay 0
+!
+interface Serial3/0
+ no ip address
+ shutdown
+ serial restart-delay 0
+!         
+interface Serial3/1
+ no ip address
+ shutdown
+ serial restart-delay 0
+!
+interface Serial3/2
+ no ip address
+ shutdown
+ serial restart-delay 0
+!
+interface Serial3/3
+ no ip address
+ shutdown
+ serial restart-delay 0
+!
+!
+no cdp log mismatch duplex
+!
+line con 0
+ exec-timeout 0 0
+ privilege level 15
+ logging synchronous
+line aux 0
+ exec-timeout 0 0
+ privilege level 15
+ logging synchronous
+!
+end

gns3/configs/vpcs_base_config.txt

@@ -0,0 +1 @@
+set pcname %h

gns3/console_cmd.py

@@ -19,30 +19,23 @@
 Handles commands typed in the GNS3 console.
 """
 
-import os
 import sys
 import cmd
-import struct
-from .qt import sip
-
-from .node import Node
-from .qt import QtCore
-from .version import __version__
-
 import logging
-log = logging.getLogger(__name__)
+import struct
+import sip
+import json
+from .qt import QtCore
+from .node import Node
+from .version import __version__
+try:
+    from gns3converter import __version__ as gns3converter_version
+except ImportError:
+    gns3converter_version = "Not installed"
 
 
 class ConsoleCmd(cmd.Cmd):
 
-    def do_env(self, args):
-        """
-        Show the environment variables used by GNS3.
-        """
-
-        for key, val in os.environ.items():
-            print("{}={}".format(key, val))
-
     def do_version(self, args):
         """
         Show the version of GNS3 and its dependencies.
@@ -52,6 +45,7 @@ class ConsoleCmd(cmd.Cmd):
         if hasattr(sys, "frozen"):
             compiled = "(compiled)"
         print("GNS3 version is {} {}".format(__version__, compiled))
+        print("GNS3 Converter version is {}".format(gns3converter_version))
         print("Python version is {}.{}.{} ({}-bit) with {} encoding".format(sys.version_info[0],
                                                                             sys.version_info[1],
                                                                             sys.version_info[2],
@@ -187,24 +181,6 @@ class ConsoleCmd(cmd.Cmd):
                             print("Cannot console to {}".format(device))
                         break
 
-    def do_log(self, args):
-        """
-        Log a message
-
-        log level message
-        """
-
-        args = args.split()
-        if len(args) == 0:
-            return
-        level = args.pop(0)
-        if level == "info":
-            log.info(" ".join(args))
-        elif level == "warning":
-            log.warning(" ".join(args))
-        else:
-            log.error(" ".join(args))
-
     def _start_console(self, node):
         """
         Starts a console application for a specific node.
@@ -212,9 +188,14 @@ class ConsoleCmd(cmd.Cmd):
         :param node: Node instance
         """
 
+        name = node.name()
         console_port = node.console()
-        from .telnet_console import nodeTelnetConsole
-        nodeTelnetConsole(node, console_port)
+        console_host = node.server().host()
+        try:
+            from .telnet_console import telnetConsole
+            telnetConsole(name, console_host, console_port)
+        except (OSError, ValueError) as e:
+            print("Cannot start console application: {}".format(e))
 
     def do_debug(self, args):
         """
@@ -232,10 +213,17 @@ class ConsoleCmd(cmd.Cmd):
             level = int(args[0])
             if level == 0:
                 print("Deactivating debugging")
+                for handler in root.handlers:
+                    if isinstance(handler, logging.StreamHandler):
+                        root.removeHandler(handler)
                 root.setLevel(logging.INFO)
             else:
-                print("Activating debugging")
-                root.setLevel(logging.DEBUG)
+                root.addHandler(logging.StreamHandler(sys.stdout))
+                if level == 1:
+                    print("Activating debugging")
+                else:
+                    print("Activating full debugging")
+                    root.setLevel(logging.DEBUG)
             from .main_window import MainWindow
             MainWindow.instance().setSettings({"debug_level": level})
         else:
@@ -270,6 +258,55 @@ class ConsoleCmd(cmd.Cmd):
                     print("{}: no such device".format(node_name))
                     continue
 
+    def _show_run(self, params):
+        """
+        Handles the 'show run' command.
+
+        :param params: list of parameters
+        """
+
+        if self._topology.project is None:
+            print("Sorry, the project hasn't been saved yet")
+            return
+
+        topology = self._topology.dump()
+        if len(params) == 1:
+            # print out whole topology
+            print(json.dumps(topology, sort_keys=True, indent=4))
+        elif len(params) >= 2:
+            # this is a 'show run <device_name>'
+            params.pop(0)
+            for param in params:
+                node_name = param
+                node_id = None
+
+                # get the node ID
+                for node in self._topology.nodes():
+                    if node.name() == node_name:
+                        node_id = node.id()
+                        break
+
+                if node_id is None:
+                    print("{}: no such device".format(node_name))
+                    continue
+
+                if "nodes" in topology["topology"]:
+                    for node in topology["topology"]["nodes"]:
+                        if node["id"] == node_id:
+                            print(json.dumps(node, sort_keys=True, indent=4))
+                            break
+
+    def _show_gnsvm(self, params):
+        """
+        Handles the 'show gns3vm' command.
+
+        :param params: list of parameters
+        """
+        from gns3.gns3_vm import GNS3VM
+        vm = GNS3VM.instance()
+        print("Running: {}".format(vm.isRunning()))
+        print("Settings: {}".format(vm.settings()))
+
     def do_show(self, args):
         """
         Show detail information about every device in current lab:
@@ -277,6 +314,15 @@ class ConsoleCmd(cmd.Cmd):
 
         Show detail information about a device:
         show device <device_name>
+
+        Show the whole topology:
+        show run
+
+        Show topology info of a device:
+        show run <device_name>
+
+        Show the GNS3 VM status
+        show gns3vm
         """
 
         if '?' in args or args.strip() == "":
@@ -286,6 +332,10 @@ class ConsoleCmd(cmd.Cmd):
         params = args.split()
         if params[0] == "device":
             self._show_device(params)
+        elif params[0] == "run":
+            self._show_run(params)
+        elif params[0] == "gns3vm":
+            self._show_gnsvm(params)
         else:
             print(self.do_show.__doc__)
 

gns3/console_view.py

@@ -15,14 +15,13 @@
 # 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 platform
 import sys
-from .qt import sip
 import struct
 import inspect
 import datetime
-import platform
 
-from .qt import QtCore, QtGui
+from .qt import QtCore
 from .topology import Topology
 from .version import __version__
 from .console_cmd import ConsoleCmd
@@ -30,39 +29,9 @@ from .pycutext import PyCutExt
 from .modules import MODULES
 from .local_config import LocalConfig
 
-import logging
-log = logging.getLogger(__name__)
-
-
-class ConsoleLogHandler(logging.StreamHandler):
-    """
-    Display log event to the console
-    """
-
-    def emit(self, record):
-        if sip.isdeleted(self._console_view):
-            return
-
-        message = self.format(record)
-        level_no = record.levelno
-        if level_no >= logging.ERROR:
-            self._console_view.write_message_signal.emit("{}\n".format(message), "error")
-        elif level_no >= logging.WARNING:
-            self._console_view.write_message_signal.emit("{}\n".format(message), "warning")
-        elif level_no >= logging.INFO:
-            # To avoid noise on console we display all event only if log level is debug
-            # or if we force the display in the log record
-            if "show" in record.__dict__ or logging.getLogger().getEffectiveLevel() == logging.DEBUG:
-                self._console_view.write_message_signal.emit("{}\n".format(message), "debug")
-        elif level_no >= logging.DEBUG:
-            self._console_view.write_message_signal.emit("{}\n".format(message), "debug")
-
 
 class ConsoleView(PyCutExt, ConsoleCmd):
 
-    # Emit this signal to write a message on console
-    write_message_signal = QtCore.Signal(str, str)
-
     def __init__(self, parent):
 
         # Set the prompt PyCutExt
@@ -72,10 +41,13 @@ class ConsoleView(PyCutExt, ConsoleCmd):
         # Set introduction message
         bitness = struct.calcsize("P") * 8
         current_year = datetime.date.today().year
-        self.intro = "GNS3 management console.\nRunning GNS3 version {} on {} ({}-bit) with Python {} Qt {} and PyQt {}.\n" \
+        self.intro = "GNS3 management console.\nRunning GNS3 version {} on {} ({}-bit) with Python {} Qt {}.\n" \
                      "Copyright (c) 2006-{} GNS3 Technologies.\n" \
                      "Use Help -> GNS3 Doctor to detect common issues." \
-                     "".format(__version__, platform.system(), bitness, platform.python_version(), QtCore.QT_VERSION_STR, QtCore.PYQT_VERSION_STR, current_year)
+                     "".format(__version__, platform.system(), bitness, platform.python_version(), QtCore.QT_VERSION_STR, current_year)
+
+        if LocalConfig.instance().experimental():
+            self.intro += "\nWARNING: Experimental features enable. You can use some unfinished features and lost data."
 
         # Parent class initialization
         try:
@@ -94,65 +66,14 @@ class ConsoleView(PyCutExt, ConsoleCmd):
         except Exception as e:
             sys.stderr.write(e)
 
-        self._handleLogs()
-
-        if LocalConfig.instance().experimental():
-            log.warning("WARNING: Experimental features enable. You can use some unfinished features and lost data.")
-
         for module in MODULES:
             instance = module.instance()
             instance.notification_signal.connect(self.writeNotification)
 
-        self.write_message_signal.connect(self._writeMessageSlot)
-
         # required for Cmd module (do_help etc.)
         self.stdout = sys.stdout
         self._topology = Topology.instance()
 
-    def contextMenuEvent(self, event):
-        """
-        Handles all context menu events.
-
-        :param event: QContextMenuEvent instance
-        """
-
-        menu = self.createStandardContextMenu()
-        delete_all_action = QtGui.QAction("Delete All", menu)
-        delete_all_action.triggered.connect(self._deleteAllActionSlot)
-        menu.addAction(delete_all_action)
-        menu.exec(event.globalPos())
-
-    def _deleteAllActionSlot(self):
-        """
-        Delete all action slot
-        """
-
-        self.clear()
-        self.write(self.prompt)
-        self.lines = []
-        self._clearLine()
-
-    def _writeMessageSlot(self, message, level):
-        """
-        Write a message in the console.
-        """
-        if level == "error":
-            self.write(message, error=True)
-        elif level == "warning":
-            self.write(message, warning=True)
-        else:
-            self.write(message)
-
-    def _handleLogs(self):
-        """
-        Catch log message and display them
-        """
-
-        log = logging.getLogger()
-        log_handler = ConsoleLogHandler()
-        log_handler._console_view = self
-        log.addHandler(log_handler)
-
     def isatty(self):
         """
         For exception handling purposes
@@ -217,64 +138,69 @@ class ConsoleView(PyCutExt, ConsoleCmd):
         """
 
         text = "Server notification: {}".format(message)
+        self.write(text, error=True)
+        self.write("\n")
         if details:
-            text += "\n" + details
-        self.write_message_signal.emit(text, "info")
+            self.write(details)
+            self.write("\n")
 
-    def writeError(self, base_node_id, message):
+    def writeError(self, node_id, message):
         """
         Write error messages.
 
-        :param base_node_id: base node identifier
+        :param node_id: node identifier
         :param message: error message
         """
 
-        node = Topology.instance().getNode(base_node_id)
+        node = Topology.instance().getNode(node_id)
         name = ""
         if node and node.name():
             name = " {}:".format(node.name())
 
         text = "Error:{name} {message}".format(name=name,
                                                message=message)
-        self.write_message_signal.emit(text, "error")
+        self.write(text, error=True)
+        self.write("\n")
 
-    def writeWarning(self, base_node_id, message):
+    def writeWarning(self, node_id, message):
         """
         Write warning messages.
 
-        :param base_node_id: base node identifier
+        :param node_id: node identifier
         :param message: warning message
         """
 
-        node = Topology.instance().getNode(base_node_id)
+        node = Topology.instance().getNode(node_id)
         name = ""
         if node and node.name():
             name = " {}:".format(node.name())
 
         text = "Warning:{name} {message}".format(name=name,
                                                  message=message)
-        self.write_message_signal.emit(text, "warning")
+        self.write(text, warning=True)
+        self.write("\n")
 
-    def writeServerError(self, base_node_id, message):
+    def writeServerError(self, node_id, message):
         """
         Write server error messages coming from the server.
 
-        :param base_node_id: Base node identifier
+        :param node_id: node identifier
         :param code: error code
         :param message: error message
         """
 
-        node = Topology.instance().getNode(base_node_id)
+        node = Topology.instance().getNode(node_id)
         server = name = ""
         if node:
             if node.name():
                 name = " {}:".format(node.name())
-            server = "from {}".format(node.compute().name())
+            server = "from {}".format(node.server().url())
 
         text = "Server error {server}:{name} {message}".format(server=server,
                                                                name=name,
                                                                message=message)
-        self.write_message_signal.emit(text.strip(), "error")
+        self.write(text, error=True)
+        self.write("\n")
 
     def _run(self):
         """

gns3/controller.py

@@ -1,508 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright (C) 2016 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 os
-import hashlib
-import tempfile
-import json
-import pathlib
-
-from .qt import QtCore, QtNetwork, QtGui, QtWidgets, QtWebSockets, qpartial, qslot
-from .symbol import Symbol
-from .local_server_config import LocalServerConfig
-from .settings import LOCAL_SERVER_SETTINGS
-
-from gns3.local_config import LocalConfig
-from gns3.utils import parse_version
-
-import logging
-log = logging.getLogger(__name__)
-
-
-class Controller(QtCore.QObject):
-    """
-    An instance of the server controller.
-    """
-
-    connected_signal = QtCore.Signal()
-    disconnected_signal = QtCore.Signal()
-    connection_failed_signal = QtCore.Signal()
-    project_list_updated_signal = QtCore.Signal()
-
-    def __init__(self):
-
-        super().__init__()
-        self._connected = False
-        self._connecting = False
-        self._notification_stream = None
-        self._version = None
-        self._cache_directory = tempfile.TemporaryDirectory(suffix="-gns3")
-        self._http_client = None
-        self._first_error = True
-        self._error_dialog = None
-        self._display_error = True
-        self._projects = []
-        self._websocket = QtWebSockets.QWebSocket()
-
-        # If we do multiple call in order to download the same symbol we queue them
-        self._static_asset_download_queue = {}
-
-    def host(self):
-
-        return self._http_client.host()
-
-    def version(self):
-        return self._version
-
-    def isRemote(self):
-        """
-        :returns Boolean: True if the controller is remote
-        """
-
-        settings = LocalServerConfig.instance().loadSettings("Server", LOCAL_SERVER_SETTINGS)
-        return not settings["auto_start"]
-
-    def connecting(self):
-        """
-        :returns: True if connection is in progress
-        """
-
-        return self._connecting
-
-    def connected(self):
-        """
-        Is the controller connected
-        """
-
-        return self._connected
-
-    def httpClient(self):
-        """
-        :returns: HTTP client to connect to the controller
-        """
-
-        return self._http_client
-
-    def setHttpClient(self, http_client):
-        """
-        :param http_client: Instance of HTTP client to communicate with the server
-        """
-
-        self._http_client = http_client
-        if self._http_client:
-            if self.isRemote():
-                self._http_client.setMaxTimeDifferenceBetweenQueries(120)
-            self._http_client.connection_connected_signal.connect(self._httpClientConnectedSlot)
-            self._http_client.connection_disconnected_signal.connect(self._httpClientDisconnectedSlot)
-            self._connectingToServer()
-
-    def getHttpClient(self):
-        """
-        :return: Instance of HTTP client to communicate with the server
-        """
-
-        return self._http_client
-
-    def setDisplayError(self, val):
-        """
-        Allow error to be visible or not
-        """
-
-        self._display_error = val
-        self._first_error = True
-
-    def _connectingToServer(self):
-        """
-        Connection process as started
-        """
-
-        self._connected = False
-        self._connecting = True
-        status, json_data = self.httpClient().getSynchronous('GET', '/version', timeout=60)
-        self._versionGetSlot(json_data, status is None or status >= 300)
-
-    def _httpClientDisconnectedSlot(self):
-        if self._connected:
-            self._connected = False
-            self.disconnected_signal.emit()
-            self._connectingToServer()
-            self.stopListenNotifications()
-
-    def _versionGetSlot(self, result, error=False, **kwargs):
-        """
-        Called after the initial version get
-        """
-
-        if error:
-            if self._first_error:
-                self._connecting = False
-                self.connection_failed_signal.emit()
-                if self._display_error:
-                    self._error_dialog = QtWidgets.QMessageBox(self.parent())
-                    self._error_dialog.setWindowModality(QtCore.Qt.WindowModality.ApplicationModal)
-                    self._error_dialog.setWindowTitle("Connection to server")
-                    if result and "message" in result:
-                        self._error_dialog.setText("Error when connecting to the GNS3 server:\n{}".format(result["message"]))
-                    else:
-                        self._error_dialog.setText("Cannot connect to the GNS3 server")
-                    self._error_dialog.setIcon(QtWidgets.QMessageBox.Icon.Critical)
-                    self._error_dialog.show()
-            # Try to connect again in 5 seconds
-            QtCore.QTimer.singleShot(5000, qpartial(self.get, '/version', self._versionGetSlot, showProgress=self._first_error))
-            self._first_error = False
-        else:
-            self._first_error = True
-            if self._error_dialog:
-                self._error_dialog.reject()
-                self._error_dialog = None
-            self._version = result.get("version")
-            self._http_client.connection_connected_signal.emit()
-
-    def _httpClientConnectedSlot(self):
-
-        if not self._connected:
-            self._connected = True
-            self._connecting = False
-            self.connected_signal.emit()
-            self.refreshProjectList()
-            self._startListenNotifications()
-
-    def post(self, *args, **kwargs):
-        return self.createHTTPQuery("POST", *args, **kwargs)
-
-    def get(self, *args, **kwargs):
-        return self.createHTTPQuery("GET", *args, **kwargs)
-
-    def put(self, *args, **kwargs):
-        return self.createHTTPQuery("PUT", *args, **kwargs)
-
-    def delete(self, *args, **kwargs):
-        return self.createHTTPQuery("DELETE", *args, **kwargs)
-
-    def getCompute(self, path, compute_id, *args, **kwargs):
-        """
-        API get on a specific compute
-        """
-
-        compute_id = self.__fix_compute_id(compute_id)
-        path = "/computes/{}{}".format(compute_id, path)
-        return self.get(path, *args, **kwargs)
-
-    def postCompute(self, path, compute_id, *args, **kwargs):
-        """
-        API post on a specific compute
-        """
-
-        compute_id = self.__fix_compute_id(compute_id)
-        path = "/computes/{}{}".format(compute_id, path)
-        return self.post(path, *args, **kwargs)
-
-    def __fix_compute_id(self, compute_id):
-        """
-        Support for remote server <= 1.5
-        This fix should be not require after the 2.1
-        when all the templates will be managed on server
-        """
-
-        #FIXME: remove this?
-        if compute_id.startswith("http:") or compute_id.startswith("https:"):
-            from .compute_manager import ComputeManager
-            try:
-                return ComputeManager.instance().getCompute(compute_id).id()
-            except KeyError:
-                return compute_id
-        return compute_id
-
-    def getEndpoint(self, path, compute_id, *args, **kwargs):
-        """
-        API post on a specific compute
-        """
-
-        compute_id = self.__fix_compute_id(compute_id)
-        path = "/computes/endpoint/{}{}".format(compute_id, path)
-        return self.get(path, *args, **kwargs)
-
-    def putCompute(self, path, compute_id, *args, **kwargs):
-        """
-        API put on a specific compute
-        """
-
-        compute_id = self.__fix_compute_id(compute_id)
-        path = "/computes/{}{}".format(compute_id, path)
-        return self.put(path, *args, **kwargs)
-
-    def createHTTPQuery(self, method, path, *args, **kwargs):
-        """
-        Forward the query to the HTTP client or controller depending on the path
-        """
-
-        if self._http_client:
-            return self._http_client.createHTTPQuery(method, path, *args, **kwargs)
-
-    @staticmethod
-    def instance():
-        """
-        Singleton to return only on instance of Controller.
-        :returns: instance of Controller
-        """
-
-        if not hasattr(Controller, '_instance') or Controller._instance is None:
-            Controller._instance = Controller()
-        return Controller._instance
-
-    def getStatic(self, url, callback, fallback=None):
-        """
-        Get a URL from the /static on controller and cache it on disk
-
-        :param url: URL without the protocol and host part
-        :param callback: Callback to call when file is ready
-        :param fallback: Fallback url in case of error
-        """
-
-        if not self._http_client:
-            return
-
-        path = self.getStaticCachedPath(url)
-
-        if os.path.exists(path):
-            callback(path)
-        elif path in self._static_asset_download_queue:
-            self._static_asset_download_queue[path].append((callback, fallback, ))
-        else:
-            self._static_asset_download_queue[path] = [(callback, fallback, )]
-            self._http_client.createHTTPQuery("GET", url, qpartial(self._getStaticCallback, url, path))
-
-    def _getStaticCallback(self, url, path, result, error=False, raw_body=None, **kwargs):
-        if path not in self._static_asset_download_queue:
-            return
-
-        if error:
-            fallback_used = False
-            for callback, fallback in self._static_asset_download_queue[path]:
-                if fallback:
-                    self.getStatic(fallback, callback)
-                fallback_used = True
-            if fallback_used:
-                log.debug("Error while downloading file: {}".format(url))
-            del self._static_asset_download_queue[path]
-            return
-        try:
-            with open(path, "wb+") as f:
-                f.write(raw_body)
-        except OSError as e:
-            log.error("Can't write to {}: {}".format(path, str(e)))
-            return
-        log.debug("File stored {} for {}".format(path, url))
-        for callback, fallback in self._static_asset_download_queue[path]:
-            callback(path)
-        del self._static_asset_download_queue[path]
-
-    def getStaticCachedPath(self, url):
-        """
-        Returns static cached (hashed) path
-
-        :param url:
-        """
-        m = hashlib.md5()
-        m.update(url.encode())
-        if ".svg" in url:
-            extension = ".svg"
-        else:
-            extension = ".png"
-        path = os.path.join(self._cache_directory.name, m.hexdigest() + extension)
-        return path
-
-    def clearStaticCache(self):
-        """
-        Clear the cache directory.
-        """
-
-        for filename in os.listdir(self._cache_directory.name):
-            if filename.endswith(".svg") or filename.endswith(".png"):
-                try:
-                    os.remove(os.path.join(self._cache_directory.name, filename))
-                except OSError as e:
-                    log.debug("Error deleting cached symbol '{}':{}".format(filename, e))
-                    continue
-
-    def getSymbolIcon(self, symbol_id, callback, fallback=None):
-        """
-        Get a QIcon for a symbol from the controller
-
-        :param symbol_id: Symbol id
-        :param callback: Callback to call when file is ready
-        :param fallback: Fallback symbol if not found
-        """
-        if symbol_id is None:
-            self.getStatic(Symbol(fallback).url(), qpartial(self._getIconCallback, callback))
-        else:
-            if fallback:
-                fallback = Symbol(fallback).url()
-            self.getStatic(Symbol(symbol_id).url(), qpartial(self._getIconCallback, callback), fallback=fallback)
-
-    def _getIconCallback(self, callback, path):
-
-        pixmap = QtGui.QPixmap(path)
-        if pixmap.isNull():
-            log.debug("Invalid symbol {}".format(path))
-            path = ":/icons/cancel.svg"
-        icon = QtGui.QIcon()
-        icon.addFile(path)
-        callback(icon)
-
-    def uploadSymbol(self, symbol_id, path):
-
-        self.post("/symbols/" + symbol_id + "/raw",
-                  qpartial(self._finishSymbolUpload, path),
-                  body=pathlib.Path(path), progressText="Uploading {}".format(symbol_id), timeout=None)
-
-    def _finishSymbolUpload(self, path, result, error=False, **kwargs):
-
-        if error:
-            log.error("Error while uploading symbol: {}: {}".format(path, result.get("message", "unknown")))
-            return
-
-        # Refresh the templates list
-        from .template_manager import TemplateManager
-        TemplateManager.instance().templates_changed_signal.emit()
-
-    def getSymbols(self, callback):
-        self.get('/symbols', callback=callback)
-
-    def deleteProject(self, project_id, callback=None):
-        Controller.instance().delete("/projects/{}".format(project_id), qpartial(self._deleteProjectCallback, callback=callback, project_id=project_id))
-
-    def _deleteProjectCallback(self, result, error=False, project_id=None, callback=None, **kwargs):
-        if error:
-            log.error("Error while deleting project: {}".format(result["message"]))
-        else:
-            self.refreshProjectList()
-
-        self._projects = [p for p in self._projects if p["project_id"] != project_id]
-
-        if callback:
-            callback(result, error=error, **kwargs)
-
-    @qslot
-    def refreshProjectList(self, *args):
-        self.get("/projects", self._projectListCallback)
-
-    def _projectListCallback(self, result, error=False, **kwargs):
-        if not error:
-            self._projects = result
-        self.project_list_updated_signal.emit()
-
-    def projects(self):
-        return self._projects
-
-    def _startListenNotifications(self):
-        if not self.connected():
-            return
-
-        # Due to bug in Qt on some version we need a dedicated network manager
-        self._notification_network_manager = QtNetwork.QNetworkAccessManager()
-        self._notification_stream = None
-
-        # Qt websocket before Qt 5.6 doesn't support auth
-        if parse_version(QtCore.QT_VERSION_STR) < parse_version("5.6.0") or parse_version(QtCore.PYQT_VERSION_STR) < parse_version("5.6.0") or LocalConfig.instance().experimental():
-
-            self._notification_stream = Controller.instance().createHTTPQuery("GET", "/notifications", self._endListenNotificationCallback,
-                                                                              downloadProgressCallback=self._event_received,
-                                                                              networkManager=self._notification_network_manager,
-                                                                              timeout=None,
-                                                                              showProgress=False,
-                                                                              ignoreErrors=True)
-            url = self._http_client.url() + '/notifications'
-            log.info("Listening for controller notifications on '{}'".format(url))
-
-        else:
-            self._notification_stream = self._http_client.connectWebSocket(self._websocket, "/notifications/ws")
-            self._notification_stream.textMessageReceived.connect(self._websocket_event_received)
-            if parse_version(QtCore.QT_VERSION_STR) < parse_version("6.5.0"):
-                self._notification_stream.error.connect(self._websocket_error)
-            else:
-                self._notification_stream.errorOccurred.connect(self._websocket_error)
-            self._notification_stream.sslErrors.connect(self._sslErrorsSlot)
-            log.info("Listening for controller notifications on '{}'".format(self._notification_stream.requestUrl().toString()))
-
-    def stopListenNotifications(self):
-        if self._notification_stream:
-            log.debug("Stop listening for notifications from controller")
-            stream = self._notification_stream
-            self._notification_stream = None
-            stream.abort()
-            self._notification_network_manager = None
-
-    def _endListenNotificationCallback(self, result, error=False, **kwargs):
-        """
-        If notification stream disconnect we reconnect to it
-        """
-        if self._notification_stream:
-            self._notification_stream = None
-            self._startListenNotifications()
-
-    @qslot
-    def _websocket_error(self, error):
-        if self._notification_stream:
-            log.error("Websocket controller notification stream error: {}".format(self._notification_stream.errorString()))
-            self._notification_stream = None
-            self._startListenNotifications()
-
-    @qslot
-    def _sslErrorsSlot(self, ssl_errors):
-
-        self._http_client.handleSslError(self._notification_stream, ssl_errors)
-
-    @qslot
-    def _websocket_event_received(self, event):
-        try:
-            self._event_received(json.loads(event))
-        except ValueError as e:
-            log.error("Invalid event received: {}".format(e))
-
-    def _event_received(self, result, *args, **kwargs):
-
-        # Log only relevant events
-        if result["action"] not in ("ping", "compute.updated"):
-            log.debug("Event received from controller stream: {}".format(result))
-        if result["action"] == "template.created" or result["action"] == "template.updated":
-            from gns3.template_manager import TemplateManager
-            TemplateManager.instance().templateDataReceivedCallback(result["event"])
-        elif result["action"] == "template.deleted":
-            from gns3.template_manager import TemplateManager
-            TemplateManager.instance().deleteTemplateCallback(result["event"])
-        elif result["action"] == "compute.created" or result["action"] == "compute.updated":
-            from .compute_manager import ComputeManager
-            ComputeManager.instance().computeDataReceivedCallback(result["event"])
-        elif result["action"] == "project.closed":
-            from .topology import Topology
-            project = Topology.instance().project()
-            if project and project.id() == result["event"]["project_id"]:
-                Topology.instance().setProject(None)
-        elif result["action"] == "project.updated":
-            from .topology import Topology
-            project = Topology.instance().project()
-            if project and project.id() == result["event"]["project_id"]:
-                project.projectUpdatedCallback(result["event"])
-        elif result["action"] == "log.error" and result["event"].get("message"):
-            log.error(result["event"].get("message"))
-        elif result["action"] == "log.warning" and result["event"].get("message"):
-            log.warning(result["event"].get("message"))
-        elif result["action"] == "log.info" and result["event"].get("message"):
-            log.info(result["event"].get("message"), extra={"show": True})
-        elif result["action"] == "ping":
-            pass

gns3/crash_report.py

@@ -15,20 +15,20 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-try:
-    import sentry_sdk
-    from sentry_sdk.integrations.logging import LoggingIntegration
-    SENTRY_SDK_AVAILABLE = True
-except ImportError:
-    # Sentry SDK is not installed with deb package in order to simplify packaging
-    SENTRY_SDK_AVAILABLE = False
-
 import sys
+import psutil
 import os
 import platform
 import struct
-import distro
 
+try:
+    import raven
+    RAVEN_AVAILABLE = True
+except ImportError:
+    # raven is not installed with deb package in order to simplify packaging
+    RAVEN_AVAILABLE = False
+
+from .utils.get_resource import get_resource
 from .version import __version__, __version_info__
 
 import logging
@@ -40,7 +40,7 @@ if __version_info__[3] != 0:
     import faulthandler
     # Display a traceback in case of segfault crash. Usefull when frozen
     # Not enabled by default for security reason
-    log.debug("Enable catching segfault")
+    log.info("Enable catching segfault")
     faulthandler.enable()
 
 
@@ -50,46 +50,44 @@ class CrashReport:
     Report crash to a third party service
     """
 
-    DSN = "https://dd662ce99d7e4a04714a89939ec523c9@o19455.ingest.us.sentry.io/38506"
+    DSN = "sync+https://1a291723e0d349b4b7e183a2ed409cd7:89c87ae5097c41ee877a5b0fa7cd1a7f@sentry.io/38506"
+    if hasattr(sys, "frozen"):
+        cacert = get_resource("cacert.pem")
+        if cacert is not None and os.path.isfile(cacert):
+            DSN += "?ca_certs={}".format(cacert)
+        else:
+            log.warning("The SSL certificate bundle file '{}' could not be found".format(cacert))
     _instance = None
 
     def __init__(self):
-        # We don't want sentry making noise if an error is caught when we don't have internet
+        # We don't want sentry making noise if an error is catched when you don't have internet
         sentry_errors = logging.getLogger('sentry.errors')
         sentry_errors.disabled = True
 
         sentry_uncaught = logging.getLogger('sentry.errors.uncaught')
         sentry_uncaught.disabled = True
-        self._sentry_initialized = False
 
-        if SENTRY_SDK_AVAILABLE:
-            # Don't send log records as events.
-            sentry_logging = LoggingIntegration(level=logging.INFO, event_level=None)
-            try:
-                sentry_sdk.init(dsn=CrashReport.DSN,
-                                release=__version__,
-                                default_integrations=False,
-                                integrations=[sentry_logging])
-            except Exception as e:
-                log.error("Crash report could not be sent: {}".format(e))
+    def captureException(self, exception, value, tb):
+        from .servers import Servers
+
+        local_server = Servers.instance().localServerSettings()
+        if local_server["report_errors"]:
+            if not RAVEN_AVAILABLE:
+                return
+            if os.path.exists(".git"):
+                log.warning("A .git directory exist crash report is turn off for developers")
                 return
 
-            tags = {
+            if hasattr(exception, "fingerprint"):
+                client = raven.Client(CrashReport.DSN, release=__version__, fingerprint=['{{ default }}', exception.fingerprint])
+            else:
+                client = raven.Client(CrashReport.DSN, release=__version__)
+            context = {
                 "os:name": platform.system(),
                 "os:release": platform.release(),
                 "os:win_32": " ".join(platform.win32_ver()),
                 "os:mac": "{} {}".format(platform.mac_ver()[0], platform.mac_ver()[2]),
-                "os:linux": distro.name(pretty=True),
-
-            }
-
-            self._add_qt_information(tags)
-
-            with sentry_sdk.configure_scope() as scope:
-                for key, value in tags.items():
-                    scope.set_tag(key, value)
-
-            extra_context = {
+                "os:linux": " ".join(platform.linux_distribution()),
                 "python:version": "{}.{}.{}".format(sys.version_info[0],
                                                     sys.version_info[1],
                                                     sys.version_info[2]),
@@ -97,64 +95,26 @@ class CrashReport:
                 "python:encoding": sys.getdefaultencoding(),
                 "python:frozen": "{}".format(hasattr(sys, "frozen"))
             }
-
-            # extra controller and compute information
-            from .controller import Controller
-            from .compute_manager import ComputeManager
-            extra_context["controller:version"] = Controller.instance().version()
-            extra_context["controller:host"] = Controller.instance().host()
-            extra_context["controller:connected"] = Controller.instance().connected()
-
-            for index, compute in enumerate(ComputeManager.instance().computes()):
-                extra_context["compute{}:id".format(index)] = compute.id()
-                extra_context["compute{}:name".format(index)] = compute.name(),
-                extra_context["compute{}:host".format(index)] = compute.host(),
-                extra_context["compute{}:connected".format(index)] = compute.connected()
-                extra_context["compute{}:platform".format(index)] = compute.capabilities().get("platform")
-                extra_context["compute{}:version".format(index)] = compute.capabilities().get("version")
-
-            with sentry_sdk.configure_scope() as scope:
-                for key, value in extra_context.items():
-                    scope.set_extra(key, value)
-
-    def captureException(self, exception, value, tb):
-
-        from .local_server import LocalServer
-        from .local_config import LocalConfig
-
-        local_server = LocalServer.instance().localServerSettings()
-        if local_server["report_errors"]:
-
-            if not SENTRY_SDK_AVAILABLE:
-                log.warning("Cannot capture exception: Sentry SDK is not available")
-                return
-
-            if os.path.exists(LocalConfig.instance().runAsRootPath()):
-                log.warning("User is running application as root. Crash reports disabled.")
-                return
-
-            if not hasattr(sys, "frozen") and os.path.exists(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", ".git")):
-                log.warning(".git directory detected, crash reporting is turned off for developers.")
-                return
-
+            context = self._add_qt_information(context)
+            client.tags_context(context)
             try:
-                error = (exception, value, tb)
-                sentry_sdk.capture_exception(error=error)
-                log.info("Crash report sent with event ID: {}".format(sentry_sdk.last_event_id()))
+                report = client.captureException((exception, value, tb))
             except Exception as e:
-                log.warning("Can't send crash report to Sentry: {}".format(e))
-
-    def _add_qt_information(self, tags):
+                log.error("Can't send crash report to Sentry: {}".format(e))
+                return
+            log.info("Crash report sent with event ID: {}".format(client.get_ident(report)))
 
+    def _add_qt_information(self, context):
         try:
             from .qt import QtCore
-            from .qt import sip
+            import sip
         except ImportError:
-            return tags
-        tags["pyqt:version"] = QtCore.PYQT_VERSION_STR
-        tags["qt:version"] = QtCore.QT_VERSION_STR
-        tags["sip:version"] = sip.SIP_VERSION_STR
-        return tags
+            return context
+        context["psutil:version"] = psutil.__version__
+        context["pyqt:version"] = QtCore.PYQT_VERSION_STR
+        context["qt:version"] = QtCore.QT_VERSION_STR
+        context["sip:version"] = sip.SIP_VERSION_STR
+        return context
 
     @classmethod
     def instance(cls):

gns3/dialogs/capture_dialog.py

@@ -1,75 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2016 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/>.
-
-from gns3.qt import QtWidgets
-from gns3.ui.capture_dialog_ui import Ui_CaptureDialog
-
-import logging
-log = logging.getLogger(__name__)
-
-
-class CaptureDialog(QtWidgets.QDialog, Ui_CaptureDialog):
-    """
-    This dialog allow to configure the packet capture
-    """
-
-    def __init__(self, parent, file_name, auto_start, ethernet_link=True):
-
-        super().__init__(parent)
-        self.setupUi(self)
-        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Ok).clicked.connect(self._okButtonClickedSlot)
-        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Cancel).clicked.connect(self.reject)
-
-        if ethernet_link:
-            self.uiDataLinkTypeComboBox.addItem("Ethernet", "DLT_EN10MB")
-        else:
-            self.uiDataLinkTypeComboBox.addItem("Cisco HDLC", "DLT_C_HDLC")
-            self.uiDataLinkTypeComboBox.addItem("Cisco PPP", "DLT_PPP_SERIAL")
-            self.uiDataLinkTypeComboBox.addItem("Frame Relay", "DLT_FRELAY")
-            self.uiDataLinkTypeComboBox.addItem("ATM", "DLT_ATM_RFC1483")
-
-        self.uiCaptureFileNameLineEdit.setText(file_name)
-        self.uiStartCommandCheckBox.setChecked(auto_start)
-
-    def _okButtonClickedSlot(self):
-        if len(self.fileName()) == 0:
-            QtWidgets.QMessageBox.warning(self.parent(), "Packet capture", "Please provide a file name for the capture")
-            return
-        self.accept()
-
-    def fileName(self):
-        return self.uiCaptureFileNameLineEdit.text()
-
-    def dataLink(self):
-        """
-        Type of link for capture
-        """
-        return self.uiDataLinkTypeComboBox.currentData()
-
-    def commandAutoStart(self):
-        return self.uiStartCommandCheckBox.isChecked()
-
-
-if __name__ == '__main__':
-    import sys
-    app = QtWidgets.QApplication(sys.argv)
-    main = QtWidgets.QMainWindow()
-    dialog = CaptureDialog(main, "test.pcap")
-    dialog.show()
-    exit_code = app.exec()
-    print(dialog.dataLink())
-    print(dialog.fileName())

gns3/dialogs/configuration_dialog.py

@@ -49,9 +49,6 @@ class ConfigurationDialog(QtWidgets.QDialog, Ui_configurationDialog):
         self._settings = settings
         self._configuration_page = configuration_page
 
-    def settings(self):
-        return self._settings
-
     def on_uiButtonBox_clicked(self, button):
         """
         Slot called when a button of the uiButtonBox is clicked.
@@ -59,7 +56,7 @@ class ConfigurationDialog(QtWidgets.QDialog, Ui_configurationDialog):
         :param button: button that was clicked (QAbstractButton)
         """
 
-        if button == self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Cancel):
+        if button == self.uiButtonBox.button(QtWidgets.QDialogButtonBox.Cancel):
             QtWidgets.QDialog.reject(self)
         else:
             try:

gns3/dialogs/console_command_dialog.py

@@ -22,8 +22,8 @@ from gns3.qt import QtWidgets
 from gns3.local_config import LocalConfig
 from gns3.ui.console_command_dialog_ui import Ui_uiConsoleCommandDialog
 from gns3.settings import PRECONFIGURED_TELNET_CONSOLE_COMMANDS, \
+        PRECONFIGURED_SERIAL_CONSOLE_COMMANDS,                   \
         PRECONFIGURED_VNC_CONSOLE_COMMANDS,                      \
-        PRECONFIGURED_SPICE_CONSOLE_COMMANDS,                    \
         CUSTOM_CONSOLE_COMMANDS_SETTINGS
 
 
@@ -39,14 +39,11 @@ class ConsoleCommandDialog(QtWidgets.QDialog, Ui_uiConsoleCommandDialog):
 
     def __init__(self, parent, console_type="telnet", current=None):
         """
-        :params console_type: telnet, serial, vnc or spice
+        :params console_type: telnet, serial or vnc
         :params current: Current console command
         """
         super().__init__(parent)
         self.setupUi(self)
-        if console_type == "spice+agent":
-            # special case for spice+agent, use the spice console type
-            console_type = "spice"
         self._console_type = console_type
         self._current = current
 
@@ -66,8 +63,8 @@ class ConsoleCommandDialog(QtWidgets.QDialog, Ui_uiConsoleCommandDialog):
         elif self._console_type == "vnc":
             self._consoles = copy.copy(PRECONFIGURED_VNC_CONSOLE_COMMANDS)
             self._consoles.update(self._settings[self._console_type])
-        elif self._console_type == "spice":
-            self._consoles = copy.copy(PRECONFIGURED_SPICE_CONSOLE_COMMANDS)
+        else:
+            self._consoles = copy.copy(PRECONFIGURED_SERIAL_CONSOLE_COMMANDS)
             self._consoles.update(self._settings[self._console_type])
 
         self.uiCommandComboBox.clear()
@@ -93,7 +90,7 @@ class ConsoleCommandDialog(QtWidgets.QDialog, Ui_uiConsoleCommandDialog):
         """
         Save a custom command to the list
         """
-        name, ok = QtWidgets.QInputDialog.getText(self, "Add a command", "Command name:", QtWidgets.QLineEdit.EchoMode.Normal)
+        name, ok = QtWidgets.QInputDialog.getText(self, "Add a command", "Command name:", QtWidgets.QLineEdit.Normal)
         command = self.uiCommandPlainTextEdit.toPlainText().strip()
         if ok and len(command) > 0:
             if command not in self._consoles.values():
@@ -123,9 +120,9 @@ class ConsoleCommandDialog(QtWidgets.QDialog, Ui_uiConsoleCommandDialog):
     def getCommand(parent, console_type="telnet", current=None):
         dialog = ConsoleCommandDialog(parent, console_type=console_type, current=current)
         dialog.show()
-        if dialog.exec():
-            return True, dialog.uiCommandPlainTextEdit.toPlainText().replace("\n", " ")
-        return False, None
+        if dialog.exec_():
+            return (True, dialog.uiCommandPlainTextEdit.toPlainText().replace("\n", " "))
+        return (False, None)
 
 
 if __name__ == '__main__':

gns3/dialogs/custom_adapters_configuration_dialog.py

@@ -1,205 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2018 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 adapters configuration.
-"""
-
-import textwrap
-import re
-
-from ..qt import QtCore, QtWidgets
-from ..ui.custom_adapters_configuration_dialog_ui import Ui_CustomAdaptersConfigurationDialog
-
-
-class NoEditDelegate(QtWidgets.QStyledItemDelegate):
-
-    def __init__(self, parent=None):
-        QtWidgets.QStyledItemDelegate.__init__(self, parent=parent)
-
-    def createEditor(self, parent, option, index):
-        return None
-
-
-class TreeWidgetItem(QtWidgets.QTreeWidgetItem):
-
-    def __lt__(self, other):
-        column = self.treeWidget().sortColumn()
-        key1 = self.text(column)
-        key2 = other.text(column)
-        return self.natural_sort_key(key1) < self.natural_sort_key(key2)
-
-    @staticmethod
-    def natural_sort_key(key):
-        regex = r'(\d*\.\d+|\d+)'
-        parts = re.split(regex, key)
-        return tuple((e if i % 2 == 0 else float(e)) for i, e in enumerate(parts))
-
-
-class CustomAdaptersConfigurationDialog(QtWidgets.QDialog, Ui_CustomAdaptersConfigurationDialog):
-    """
-    Custom adapters configuration dialog.
-
-    :param parent: parent widget
-    """
-
-    def __init__(self, ports, custom_adapters, default_adapter_type=None, adapter_types=None, base_mac_address=None, parent=None):
-
-        super().__init__(parent)
-        self.setupUi(self)
-        self._ports = ports
-        self._default_adapter_type = default_adapter_type
-        self._adapter_types = adapter_types
-        self._custom_adapters = custom_adapters
-        self._base_mac_address = base_mac_address
-
-        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Reset).clicked.connect(self._resetSlot)
-
-        if self._default_adapter_type and self._adapter_types:
-            self.uiAdaptersTreeWidget.setColumnCount(3)
-            self.uiAdaptersTreeWidget.headerItem().setText(2, "Adapter type")
-
-        if self._base_mac_address:
-            self.uiAdaptersTreeWidget.setColumnCount(4)
-            self.uiAdaptersTreeWidget.headerItem().setText(3, "MAC address")
-
-        self._populateWidgets()
-
-        # resize to fit the tree widget
-        width = 0
-        for column in range(self.uiAdaptersTreeWidget.columnCount()):
-            width += 20 + self.uiAdaptersTreeWidget.columnWidth(column)
-        self.resize(QtCore.QSize(width, self.height()))
-
-    def _getCustomAdapterSettings(self, adapter_number):
-
-        for custom_adapter in self._custom_adapters:
-            if custom_adapter["adapter_number"] == adapter_number:
-                return custom_adapter
-        return {}
-
-    def _MacToInteger(self, mac_address):
-        """
-        Convert a macaddress with the format 00:0c:29:11:b0:0a to a int
-
-        :param mac_address: The mac address
-
-        :returns: Integer
-        """
-
-        return int(mac_address.replace(":", ""), 16)
-
-    def _IntegerToMac(self, integer):
-        """
-        Convert an integer to a mac address
-        """
-
-        return ":".join(textwrap.wrap("%012x" % (integer), width=2))
-
-    def _populateWidgets(self):
-
-        adapter_number = 0
-        for port_name in self._ports:
-            item = TreeWidgetItem(self.uiAdaptersTreeWidget)
-            item.setFlags(item.flags() | QtCore.Qt.ItemFlag.ItemIsEditable)
-            item.setText(0, "Adapter {}".format(adapter_number))
-            item.setData(0, QtCore.Qt.ItemDataRole.UserRole, adapter_number)
-            item.setData(1, QtCore.Qt.ItemDataRole.UserRole, port_name)
-            custom_adapter = self._getCustomAdapterSettings(adapter_number)
-            item.setText(1, custom_adapter.get("port_name", port_name))
-
-            if self._default_adapter_type and self._adapter_types:
-                combobox = QtWidgets.QComboBox(self)
-                if type(self._adapter_types) == list:
-                    for adapter_type in self._adapter_types:
-                        combobox.addItem("{}".format(adapter_type))
-                else:
-                    index = 0
-                    for adapter_type, adapter_description in self._adapter_types.items():
-                        combobox.addItem("{}".format(adapter_type))
-                        combobox.setItemData(index, adapter_description, QtCore.Qt.ItemDataRole.ToolTipRole)
-                        index += 1
-                adapter_type_index = combobox.findText(custom_adapter.get("adapter_type", self._default_adapter_type))
-                combobox.setCurrentIndex(adapter_type_index)
-                self.uiAdaptersTreeWidget.setItemWidget(item, 2, combobox)
-
-            if self._base_mac_address:
-                self.uiAdaptersTreeWidget.addTopLevelItem(item)
-                line_edit = QtWidgets.QLineEdit(self)
-                line_edit.setInputMask("HH:HH:HH:HH:HH:HH;_")
-                mac_address = self._IntegerToMac(self._MacToInteger(self._base_mac_address) + adapter_number)
-                line_edit.setText(custom_adapter.get("mac_address", mac_address))
-                self.uiAdaptersTreeWidget.setItemWidget(item, 3, line_edit)
-            adapter_number += 1
-
-        self.uiAdaptersTreeWidget.setItemDelegateForColumn(0, NoEditDelegate(self))
-        self.uiAdaptersTreeWidget.sortByColumn(0, QtCore.Qt.SortOrder.AscendingOrder)
-        self.uiAdaptersTreeWidget.setSortingEnabled(True)
-
-        for column in range(self.uiAdaptersTreeWidget.columnCount()):
-            self.uiAdaptersTreeWidget.resizeColumnToContents(column)
-
-    def _resetSlot(self):
-
-        self.uiAdaptersTreeWidget.clear()
-        self._custom_adapters.clear()
-        self._populateWidgets()
-
-    def _updateCustomAdapters(self):
-
-        self._custom_adapters.clear()
-        for row in range(self.uiAdaptersTreeWidget.topLevelItemCount()):
-            custom_adapter_settings = {}
-            item = self.uiAdaptersTreeWidget.topLevelItem(row)
-            port_name = item.text(1)
-            adapter_number = item.data(0, QtCore.Qt.ItemDataRole.UserRole)
-            custom_adapter_settings["adapter_number"] = adapter_number
-            original_port_name = item.data(1, QtCore.Qt.ItemDataRole.UserRole)
-            if not port_name:
-                QtWidgets.QMessageBox.critical(self, "Port name", "Port name cannot be empty for adapter {}".format(adapter_number))
-                return False
-            if original_port_name != port_name:
-                custom_adapter_settings["port_name"] = port_name
-            if self._default_adapter_type and self._adapter_types:
-                adapter_type = self.uiAdaptersTreeWidget.itemWidget(item, 2).currentText()
-                if self._default_adapter_type != adapter_type:
-                    custom_adapter_settings["adapter_type"] = adapter_type
-            if self._base_mac_address:
-                mac_address = self.uiAdaptersTreeWidget.itemWidget(item, 3).text()
-                if mac_address and mac_address != ":::::":
-                    if not re.search(r"""^([0-9a-fA-F]{2}[:]){5}[0-9a-fA-F]{2}$""", mac_address):
-                        QtWidgets.QMessageBox.critical(self, "MAC address", "Invalid MAC address (format required: hh:hh:hh:hh:hh:hh)")
-                        return False
-                    default_mac_address = self._IntegerToMac(self._MacToInteger(self._base_mac_address) + adapter_number)
-                    if mac_address != default_mac_address:
-                        custom_adapter_settings["mac_address"] = mac_address
-            if len(custom_adapter_settings) > 1:
-                # only save if there is more than the adapter_number key
-                self._custom_adapters.append(custom_adapter_settings.copy())
-        return True
-
-    def done(self, result):
-        """
-        Called when the dialog is closed.
-
-        :param result: boolean (accepted or rejected)
-        """
-
-        if result:
-            if not self._updateCustomAdapters():
-                return
-        super().done(result)

gns3/dialogs/doctor_dialog.py

@@ -24,7 +24,7 @@ import struct
 
 from gns3.qt import QtWidgets
 from gns3.ui.doctor_dialog_ui import Ui_DoctorDialog
-from gns3.local_server import LocalServer
+from gns3.servers import Servers
 from gns3.local_config import LocalConfig
 from gns3 import version
 from gns3.modules.vmware import VMware
@@ -76,7 +76,7 @@ class DoctorDialog(QtWidgets.QDialog, Ui_DoctorDialog):
 
     def checkLocalServerEnabled(self):
         """Checking if the local server is enabled"""
-        if LocalServer.instance().shouldLocalServerAutoStart() is False:
+        if Servers.instance().shouldLocalServerAutoStart() is False:
             return (2, "The local server is disabled. Go to Preferences -> Server -> Local Server and enable the local server.")
         return (0, None)
 
@@ -95,14 +95,13 @@ class DoctorDialog(QtWidgets.QDialog, Ui_DoctorDialog):
     def checkAVGInstalled(self):
         """Checking if AVG software is not installed"""
 
-        if sys.platform.startswith("win32"):
-            for proc in psutil.process_iter():
-                try:
-                    psinfo = proc.as_dict(["exe"])
-                    if psinfo["exe"] and "AVG\\" in psinfo["exe"]:
-                        return (2, "AVG has known issues with GNS3, even after you disable it. You must whitelist dynamips.exe in the AVG preferences.")
-                except psutil.NoSuchProcess:
-                    pass
+        for proc in psutil.process_iter():
+            try:
+                psinfo = proc.as_dict(["exe"])
+                if psinfo["exe"] and "AVG\\" in psinfo["exe"]:
+                    return (2, "AVG has known issues with GNS3, even after you disable it. You must whitelist dynamips.exe in the AVG preferences.")
+            except psutil.NoSuchProcess:
+                pass
         return (0, None)
 
     def checkFreeRam(self):
@@ -131,23 +130,26 @@ class DoctorDialog(QtWidgets.QDialog, Ui_DoctorDialog):
             # we are root, so we should have privileged access.
             return (0, None)
 
-        path = LocalServer.instance().localServerSettings().get("ubridge_path")
+        path = Servers.instance().localServerSettings().get("ubridge_path")
         if path is None:
             return (0, None)
         if not os.path.exists(path):
             return (2, "Ubridge path {path} doesn't exists".format(path=path))
 
+        request_setuid = False
         if sys.platform.startswith("linux"):
-            try:
-                if "security.capability" not in os.listxattr(path) or not struct.unpack("<IIIII", os.getxattr(path, "security.capability"))[1] & 1 << 13:
-                    return (2, "Ubridge requires CAP_NET_RAW. Run sudo setcap cap_net_admin,cap_net_raw=ep {path}".format(path=path))
-            except (OSError, AttributeError) as e:
-                # Due to a Python bug, os.listxattr could be missing: https://github.com/GNS3/gns3-gui/issues/2010
-                return (1, "Could not determine if CAP_NET_RAW capability is set for uBridge: {}".format(e))
+            if "security.capability" in os.listxattr(path):
+                caps = os.getxattr(path, "security.capability")
+                # test the 2nd byte and check if the 13th bit (CAP_NET_RAW) is set
+                if not struct.unpack("<IIIII", caps)[1] & 1 << 13:
+                    return(2, "Ubridge require CAP_NET_RAW. Run sudo setcap cap_net_admin,cap_net_raw=ep {path}".format(path=path))
+            else:
+                # capabilities not supported
+                request_setuid = True
 
-        if sys.platform.startswith("darwin"):
-            if os.stat(path).st_uid != 0 or not os.stat(path).st_mode & stat.S_ISUID:
-                return (2, "Ubridge should be setuid. Run sudo chown root:admin {path} and sudo chmod 4750 {path}".format(path=path))
+        if sys.platform.startswith("darwin") or request_setuid:
+             if os.stat(path).st_uid != 0 or not os.stat(path).st_mode & stat.S_ISUID:
+                return (2, "Ubridge should be setuid. Run sudo chown root {path} and sudo chmod 4755 {path}".format(path=path))
         return (0, None)
 
     def checkDynamipsPermission(self):
@@ -156,21 +158,17 @@ class DoctorDialog(QtWidgets.QDialog, Ui_DoctorDialog):
             # we are root, so we should have privileged access.
             return (0, None)
 
-        path = LocalServer.instance().localServerSettings().get("dynamips_path")
+        path = Servers.instance().localServerSettings().get("dynamips_path")
         if path is None:
             return (0, None)
         if not os.path.exists(path):
             return (2, "Dynamips path {path} doesn't exists".format(path=path))
 
-        try:
-            if sys.platform.startswith("linux") and "security.capability" in os.listxattr(path):
-                caps = os.getxattr(path, "security.capability")
-                # test the 2nd byte and check if the 13th bit (CAP_NET_RAW) is set
-                if not struct.unpack("<IIIII", caps)[1] & 1 << 13:
-                    return (2, "Dynamips requires CAP_NET_RAW. Run sudo setcap cap_net_raw,cap_net_admin+eip {path}".format(path=path))
-        except AttributeError:
-            # Due to a Python bug, os.listxattr could be missing: https://github.com/GNS3/gns3-gui/issues/2010
-            return (1, "Could not determine if CAP_NET_RAW capability is set for Dynamips (Python bug)".format(path=path))
+        if sys.platform.startswith("linux") and "security.capability" in os.listxattr(path):
+            caps = os.getxattr(path, "security.capability")
+            # test the 2nd byte and check if the 13th bit (CAP_NET_RAW) is set
+            if not struct.unpack("<IIIII", caps)[1] & 1 << 13:
+                return (2, "Dynamips require CAP_NET_RAW. Run sudo setcap cap_net_raw,cap_net_admin+eip {path}".format(path=path))
         return (0, None)
 
     def checkGNS3InstalledTwice(self):
@@ -222,5 +220,5 @@ if __name__ == '__main__':
     app = QtWidgets.QApplication(sys.argv)
     main = QtWidgets.QMainWindow()
     dialog = DoctorDialog(main, console=True)
-    # dialog.show()
-    #exit_code = app.exec()
+    #dialog.show()
+    #exit_code = app.exec_()

gns3/dialogs/edit_compute_dialog.py

@@ -1,124 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2014 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
-
-from gns3.qt import QtWidgets
-from gns3.compute import Compute
-from gns3.ui.edit_compute_dialog_ui import Ui_EditComputeDialog
-
-
-class EditComputeDialog(QtWidgets.QDialog, Ui_EditComputeDialog):
-
-    """
-    New compute dialog.
-
-    :param parent: parent widget.
-    """
-
-    def __init__(self, parent, compute=None):
-
-        super().__init__(parent)
-        self.setupUi(self)
-        self.uiEnableAuthenticationCheckBox.toggled.connect(self._enableAuthenticationSlot)
-        self._compute = compute
-        if self._compute:
-            self.uiServerNameLineEdit.setText(self._compute.name())
-            self.uiServerHostLineEdit.setText(self._compute.host())
-            self.uiServerPortSpinBox.setValue(self._compute.port())
-
-            index = self.uiServerProtocolComboBox.findText(self._compute.protocol().upper())
-            self.uiServerProtocolComboBox.setCurrentIndex(index)
-
-            if self._compute.user():
-                self.uiEnableAuthenticationCheckBox.setChecked(True)
-                self.uiServerUserLineEdit.setText(self._compute.user())
-            else:
-                self.uiEnableAuthenticationCheckBox.setChecked(False)
-                self.uiWarningLabel.setVisible(False)
-        else:
-            self.uiEnableAuthenticationCheckBox.setChecked(False)
-            self.uiWarningLabel.setVisible(False)
-        self._enableAuthenticationSlot(self.uiEnableAuthenticationCheckBox.isChecked())
-
-    def _enableAuthenticationSlot(self, state):
-        """
-        Slot to enable or not the authentication.
-        """
-
-        if self.uiEnableAuthenticationCheckBox.isChecked():
-            self.uiServerUserLineEdit.setVisible(True)
-            self.uiServerPasswordLineEdit.setVisible(True)
-            self.uiServerUserLabel.setVisible(True)
-            self.uiServerPasswordLabel.setVisible(True)
-        else:
-            self.uiServerUserLineEdit.setVisible(False)
-            self.uiServerPasswordLineEdit.setVisible(False)
-            self.uiServerUserLabel.setVisible(False)
-            self.uiServerPasswordLabel.setVisible(False)
-
-    def compute(self):
-        return self._compute
-
-    def accept(self):
-        """
-        Adds a new remote compute.
-        """
-
-        host = self.uiServerHostLineEdit.text().strip()
-        name = self.uiServerNameLineEdit.text().strip()
-        protocol = self.uiServerProtocolComboBox.currentText().lower()
-        port = self.uiServerPortSpinBox.value()
-        user = self.uiServerUserLineEdit.text().strip()
-        password = self.uiServerPasswordLineEdit.text().strip()
-
-        if not re.match(r"^[a-zA-Z0-9\.{}-]+$".format("\u0370-\u1CDF\u2C00-\u30FF\u4E00-\u9FBF"), host):
-            QtWidgets.QMessageBox.critical(self, "Remote compute", "Invalid remote server hostname {}".format(host))
-            return
-        if name == "gns3vm":
-            QtWidgets.QMessageBox.critical(self, "Remote compute", "{} is a reserved name".format(name))
-            return
-        if len(name) == 0:
-            QtWidgets.QMessageBox.critical(self, "Remote compute", "Invalid remote server name {}".format(name))
-            return
-        if port is None or port < 1:
-            QtWidgets.QMessageBox.critical(self, "Remote compute", "Invalid remote server port {}".format(port))
-            return
-
-        if not self._compute:
-            self._compute = Compute()
-        self._compute.setName(name)
-        self._compute.setProtocol(protocol)
-        self._compute.setHost(host)
-        self._compute.setPort(port)
-        if self.uiEnableAuthenticationCheckBox.isChecked():
-            self._compute.setUser(user)
-            self._compute.setPassword(password)
-        else:
-            self._compute.setUser(None)
-            self._compute.setPassword(None)
-
-        super().accept()
-
-
-if __name__ == '__main__':
-    import sys
-    app = QtWidgets.QApplication(sys.argv)
-    main = QtWidgets.QMainWindow()
-    dialog = EditComputeDialog(main)
-    dialog.show()
-    exit_code = app.exec()

gns3/dialogs/edit_project_dialog.py

@@ -1,118 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2014 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/>.
-
-from ..qt import QtWidgets, QtCore, qslot, qpartial
-from ..topology import Topology
-from ..ui.edit_project_dialog_ui import Ui_EditProjectDialog
-
-
-class EditProjectDialog(QtWidgets.QDialog, Ui_EditProjectDialog):
-    """
-    Edit current project settings
-    """
-
-    def __init__(self, parent):
-
-        super().__init__(parent)
-        self.setupUi(self)
-        self._project = Topology.instance().project()
-        self.uiProjectNameLineEdit.setText(self._project.name())
-        self.uiProjectAutoOpenCheckBox.setChecked(self._project.autoOpen())
-        self.uiProjectAutoCloseCheckBox.setChecked(not self._project.autoClose())
-        self.uiProjectAutoStartCheckBox.setChecked(self._project.autoStart())
-        self.uiSceneWidthSpinBox.setValue(self._project.sceneWidth())
-        self.uiSceneHeightSpinBox.setValue(self._project.sceneHeight())
-        self.uiNodeGridSizeSpinBox.setValue(self._project.nodeGridSize())
-        self.uiDrawingGridSizeSpinBox.setValue(self._project.drawingGridSize())
-
-        self.uiGlobalVariablesGrid.setAlignment(QtCore.Qt.AlignmentFlag.AlignTop)
-
-        self.uiNewVarButton = QtWidgets.QPushButton('Add new variable', self)
-        self.uiNewVarButton.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Fixed)
-        self.uiNewVarButton.clicked.connect(self.onAddNewVariable)
-        self.uiGlobalVariablesGrid.addWidget(self.uiNewVarButton, 0, 3, QtCore.Qt.AlignmentFlag.AlignRight)
-
-        self._variables = self._project.variables()
-        if not self._variables:
-            self._variables = [{"name": "", "value": ""}]
-        self.updateGlobalVariables()
-
-    def updateGlobalVariables(self):
-        while True:
-            item = self.uiGlobalVariablesGrid.takeAt(1)
-            if item is None:
-                break
-            elif item.widget():
-                item.widget().deleteLater()
-
-        for i, variable in enumerate(self._variables, start=1):
-            nameLabel = QtWidgets.QLabel()
-            nameLabel.setText("Name:")
-            self.uiGlobalVariablesGrid.addWidget(nameLabel, i, 0)
-
-            nameEdit = QtWidgets.QLineEdit()
-            nameEdit.setText(variable.get("name", ""))
-            nameEdit.textChanged.connect(qpartial(self.onNameChange, variable))
-            self.uiGlobalVariablesGrid.addWidget(nameEdit, i, 1)
-
-            valueLabel = QtWidgets.QLabel()
-            valueLabel.setText("Value:")
-            self.uiGlobalVariablesGrid.addWidget(valueLabel, i, 2)
-
-            valueEdit = QtWidgets.QLineEdit()
-            valueEdit.setText(variable.get("value", ""))
-            valueEdit.textChanged.connect(qpartial(self.onValueChange, variable))
-            self.uiGlobalVariablesGrid.addWidget(valueEdit, i, 3)
-
-    @qslot
-    def onAddNewVariable(self, event):
-        self._variables += [{"name": "", "value": ""}]
-        self.updateGlobalVariables()
-
-    def onNameChange(self, variable, text):
-        variable["name"] = text
-
-    def onValueChange(self, variable, text):
-        variable["value"] = text
-
-    def _cleanVariables(self):
-        return [v for v in self._variables if v.get("name").strip() != ""]
-
-    def done(self, result):
-        """
-        Called when the dialog is closed.
-
-        :param result: boolean (accepted or rejected)
-        """
-
-        if result:
-            node_grid_size = self.uiNodeGridSizeSpinBox.value()
-            drawing_grid_size = self.uiDrawingGridSizeSpinBox.value()
-            if node_grid_size % drawing_grid_size != 0:
-                QtWidgets.QMessageBox.critical(self, "Grid sizes", "Invalid grid sizes which will create overlapping lines")
-            else:
-                self._project.setNodeGridSize(node_grid_size)
-                self._project.setDrawingGridSize(drawing_grid_size)
-                self._project.setName(self.uiProjectNameLineEdit.text())
-                self._project.setAutoOpen(self.uiProjectAutoOpenCheckBox.isChecked())
-                self._project.setAutoClose(not self.uiProjectAutoCloseCheckBox.isChecked())
-                self._project.setAutoStart(self.uiProjectAutoStartCheckBox.isChecked())
-                self._project.setSceneHeight(self.uiSceneHeightSpinBox.value())
-                self._project.setSceneWidth(self.uiSceneWidthSpinBox.value())
-                self._project.setVariables(self._cleanVariables())
-                self._project.update()
-        super().done(result)

gns3/dialogs/export_debug_dialog.py

@@ -25,12 +25,10 @@ from gns3.version import __version__
 from gns3.qt import QtWidgets, QtCore
 from gns3.ui.export_debug_dialog_ui import Ui_ExportDebugDialog
 from gns3.local_config import LocalConfig
-from gns3.controller import Controller
 
 import logging
 log = logging.getLogger(__name__)
 
-
 class ExportDebugDialog(QtWidgets.QDialog, Ui_ExportDebugDialog):
     """
     This dialog allow user to export useful information
@@ -45,48 +43,29 @@ class ExportDebugDialog(QtWidgets.QDialog, Ui_ExportDebugDialog):
         self.uiOkButton.clicked.connect(self._okButtonClickedSlot)
 
     def _okButtonClickedSlot(self):
-        if Controller.instance().isRemote():
-            QtWidgets.QMessageBox.critical(self, "Debug", "Export debug information from a remote server is not supported")
+        path, _ = QtWidgets.QFileDialog.getSaveFileName(self, "Export debug file", None, "Zip file (*.zip)", "Zip file (*.zip)")
+
+        if len(path) == 0:
             self.reject()
             return
 
-        self._path, _ = QtWidgets.QFileDialog.getSaveFileName(self, "Export debug file", None, "Zip file (*.zip)", "Zip file (*.zip)")
-
-        if len(self._path) == 0:
-            self.reject()
-            return
-
-        if Controller.instance().connected():
-            Controller.instance().post("/debug", self._exportDebugCallback)
-        else:
-            self._exportDebugCallback({}, error=True)
-
-    def _exportDebugCallback(self, result, error=False, **kwargs):
-        log.debug("Export debug information to %s", self._path)
+        log.info("Export debug information to %s", path)
 
         try:
-            with ZipFile(self._path, 'w') as zip:
+            with ZipFile(path, 'w') as zip:
                 zip.writestr("debug.txt", self._getDebugData())
-                dir = LocalConfig.instance().configDirectory()
+                dir = LocalConfig.configDirectory()
                 for filename in os.listdir(dir):
                     path = os.path.join(dir, filename)
                     if os.path.isfile(path):
                         zip.write(path, filename)
 
-                dir = os.path.join(LocalConfig.instance().configDirectory(), "debug")
-                if os.path.exists(dir):
+                dir = self._project.filesDir()
+                if dir:
                     for filename in os.listdir(dir):
                         path = os.path.join(dir, filename)
                         if os.path.isfile(path):
                             zip.write(path, filename)
-
-                if self._project:
-                    dir = self._project.filesDir()
-                    if dir:
-                        for filename in os.listdir(dir):
-                            path = os.path.join(dir, filename)
-                            if os.path.isfile(path):
-                                zip.write(path, filename)
         except OSError as e:
             QtWidgets.QMessageBox.critical(self, "Debug", "Can't export debug information: {}".format(str(e)))
         self.accept()

gns3/dialogs/file_editor_dialog.py

@@ -32,7 +32,7 @@ class FileEditorDialog(QtWidgets.QDialog, Ui_FileEditorDialog):
     check return a tuple result and a message in case of failure.
     """
 
-    def __init__(self, target, path, parent=None, default=""):
+    def __init__(self, node, path, parent=None):
 
         if parent is None:
             from gns3.main_window import MainWindow
@@ -41,32 +41,23 @@ class FileEditorDialog(QtWidgets.QDialog, Ui_FileEditorDialog):
         super().__init__(parent)
         self.setupUi(self)
 
-        self._target = target
+        self._node = node
         self._path = path
-        self._default = default
 
-        self.setWindowTitle(target.name() + " " + os.path.basename(path))
+        self.setWindowTitle(node.name() + " " + os.path.basename(path))
 
         self.uiRefreshButton.pressed.connect(self._refreshSlot)
-        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Save).clicked.connect(self._okButtonClickedSlot)
-        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Cancel).clicked.connect(self.reject)
+        self.accepted.connect(self._acceptedCallback)
 
         self._refreshSlot()
 
-    def _okButtonClickedSlot(self):
+    def _acceptedCallback(self):
         text = self.uiFileTextEdit.toPlainText()
-        self._target.post("/files/" + self._path, self._saveCallback, body=text)
-
-    def _saveCallback(self, result, error=False, **kwargs):
-        if not error:
-            self.accept()
+        self._node.httpPost("/files" + self._path, None, body=text)
 
     def _refreshSlot(self):
-        self._target.get("/files/" + self._path, self._getCallback)
+        self._node.httpGet("/files" + self._path, self._getCallback)
 
     def _getCallback(self, result, error=False, raw_body=None, **kwargs):
         if not error:
-            self.uiFileTextEdit.setText(raw_body.decode("utf-8", errors="ignore"))
-        elif result.get("status") == 404:
-            if self._default:
-                self.uiFileTextEdit.setText(self._default)
+            self.uiFileTextEdit.setText(raw_body)

gns3/dialogs/filter_dialog.py

@@ -1,178 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2014 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/>.
-
-from ..qt import QtGui, QtWidgets, qslot
-from ..ui.filter_dialog_ui import Ui_FilterDialog
-
-import logging
-log = logging.getLogger(__name__)
-
-
-class FilterDialog(QtWidgets.QDialog, Ui_FilterDialog):
-
-    """
-    Filter dialog.
-    """
-
-    def __init__(self, parent, link):
-
-        super().__init__(parent)
-        self.setupUi(self)
-        self._link = link
-        self._filters = {}
-        self._link.updated_link_signal.connect(self._updateUiSlot)
-        self._link.listAvailableFilters(self._listAvailableFiltersCallback)
-        self._initialized = False
-        self._filter_items = {}
-        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Apply).clicked.connect(self._applyPreferencesSlot)
-        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Help).clicked.connect(self._helpSlot)
-        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Reset).clicked.connect(self._resetSlot)
-
-    def _listAvailableFiltersCallback(self, result, error=False, *args, **kwargs):
-        if error:
-            log.warning("Error while listing information about the link: {}".format(result["message"]))
-            return
-        self._filters = result
-        self._initialized = True
-        self._updateUiSlot()
-
-    @qslot
-    def _updateUiSlot(self, *args):
-
-        # Empty the main layout
-        while True:
-            item = self.uiVerticalLayout.takeAt(0)
-            if item is None:
-                break
-            elif item.widget():
-                item.widget().deleteLater()
-
-        if len(self._filters) == 0:
-            QtWidgets.QMessageBox.critical(self, "Link", "No filter available for this link. Try with a different node type.")
-            self.reject()
-
-        self._tabWidget = QtWidgets.QTabWidget(self)
-        for i, filter in enumerate(self._filters):
-            tab = QtWidgets.QWidget()
-            self._tabWidget.addTab(tab, filter['name'])
-            self._tabWidget.setTabToolTip(i, filter['description'])
-            self._tabWidget.setTabIcon(i, QtGui.QIcon(':/icons/led_red.svg'))
-            vlayout = QtWidgets.QVBoxLayout()
-
-            gridLayout = QtWidgets.QGridLayout()
-            line = 0
-            filter["spinBoxes"] = []
-            filter["textEdits"] = []
-
-            nb_spin = 0
-
-            for param in filter["parameters"]:
-                label = QtWidgets.QLabel()
-                label.setText(param["name"] + ":")
-                gridLayout.addWidget(label, line, 0, 1, 1)
-
-                if param["type"] == "int":
-                    spinBox = QtWidgets.QSpinBox()
-                    filter["spinBoxes"].append(spinBox)
-                    spinBox.setMinimum(param["minimum"])
-                    spinBox.setMaximum(param["maximum"])
-
-                    sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Fixed)
-                    sizePolicy.setHorizontalStretch(0)
-                    sizePolicy.setVerticalStretch(0)
-                    sizePolicy.setHeightForWidth(spinBox.sizePolicy().hasHeightForWidth())
-                    spinBox.setSizePolicy(sizePolicy)
-                    try:
-                        value = self._link.filters()[filter["type"]][nb_spin]
-                        spinBox.setValue(value)
-                        if value != 0:
-                            self._tabWidget.setTabIcon(i, QtGui.QIcon(':/icons/led_green.svg'))
-                    except(KeyError, IndexError):
-                        pass
-                    nb_spin += 1
-                    gridLayout.addWidget(spinBox, line, 1, 1, 1)
-                    unit = QtWidgets.QLabel()
-                    unit.setText(param["unit"])
-                    gridLayout.addWidget(unit, line, 2, 1, 1)
-                elif param["type"] == "text":
-                    textEdit = QtWidgets.QTextEdit()
-                    textEdit.setAcceptRichText(False)
-                    filter["textEdits"].append(textEdit)
-                    sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Expanding)
-                    sizePolicy.setHorizontalStretch(0)
-                    sizePolicy.setVerticalStretch(0)
-                    textEdit.setMinimumWidth(300)
-                    textEdit.setSizePolicy(sizePolicy)
-                    try:
-                        text = self._link.filters()[filter["type"]][0]
-                        textEdit.setPlainText(text)
-                        if text:
-                            self._tabWidget.setTabIcon(i, QtGui.QIcon(':/icons/led_green.svg'))
-                    except(KeyError, IndexError):
-                        pass
-                    gridLayout.addWidget(textEdit, line, 1, 1, 1)
-
-                line += 1
-
-            spacerItem = QtWidgets.QSpacerItem(1, 1, QtWidgets.QSizePolicy.Policy.Minimum, QtWidgets.QSizePolicy.Policy.Expanding)
-            gridLayout.addItem(spacerItem, line, 0, 1, 1)
-            vlayout.addLayout(gridLayout)
-            tab.setLayout(vlayout)
-
-        self.uiVerticalLayout.addWidget(self._tabWidget)
-
-    @qslot
-    def _applyPreferencesSlot(self, *args):
-        new_filters = {}
-        for filter in self._filters:
-            new_filters[filter["type"]] = []
-            for spinBox in filter["spinBoxes"]:
-                new_filters[filter["type"]].append(spinBox.value())
-            for spinBox in filter["textEdits"]:
-                new_filters[filter["type"]].append(spinBox.toPlainText())
-        self._link.setFilters(new_filters)
-        self._link.update()
-
-    @qslot
-    def _helpSlot(self, *args):
-        help_text = "Filters are applied to packets in both direction.\n\n"
-
-        filter_nb = 0
-        for filter in self._filters:
-            help_text += "{}: {}".format(filter["name"], filter["description"])
-            filter_nb += 1
-            if len(self._filters) != filter_nb:
-                help_text += "\n\n"
-
-        QtWidgets.QMessageBox.information(self, "Help for filters", help_text)
-
-    @qslot
-    def _resetSlot(self, *args):
-
-        filters = {}
-        self._link.setFilters(filters)
-        self._link.update()
-
-    def done(self, result):
-        """
-        Called when the dialog is closed.
-
-        :param result: boolean (accepted or rejected)
-        """
-        if result and self._initialized:
-            self._applyPreferencesSlot()
-        super().done(result)

gns3/dialogs/idlepc_dialog.py

@@ -33,15 +33,14 @@ class IdlePCDialog(QtWidgets.QDialog, Ui_IdlePCDialog):
 
         super().__init__(parent)
         self.setupUi(self)
-        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Apply).clicked.connect(self._applySlot)
-        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Help).clicked.connect(self._helpSlot)
+        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.Apply).clicked.connect(self._applySlot)
+        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.Help).clicked.connect(self._helpSlot)
 
         self._router = router
         self._idlepcs = idlepcs
 
         for value in self._idlepcs:
-            # validate idle-pc format, e.g. 0x60c09aa0
-            match = re.search(r"^(0x[0-9a-f]{8})\s+\[(\d+)\]$", value)
+            match = re.search(r"^(0x[0-9a-f]+)\s+\[(\d+)\]$", value)
             if match:
                 idlepc = match.group(1)
                 count = int(match.group(2))
@@ -62,7 +61,7 @@ Select each value that appears in the list and click Apply, and note the CPU usa
 """
         QtWidgets.QMessageBox.information(self, "Hints for Idle-PC", help_text)
 
-    def _applySlot(self, update_template=False):
+    def _applySlot(self):
         """
         Applies an Idle-PC value.
         """
@@ -78,9 +77,8 @@ Select each value that appears in the list and click Apply, and note the CPU usa
             if hasattr(node, "idlepc") and node.settings()["image"] == ios_image:
                 node.setIdlepc(idlepc)
 
-        if update_template:
-            # apply the idle-pc to templates with the same IOS image
-            self._router.module().updateImageIdlepc(ios_image, idlepc)
+        # apply the idle-pc to templates with the same IOS image
+        self._router.module().updateImageIdlepc(ios_image, idlepc)
 
     def done(self, result):
         """
@@ -90,5 +88,5 @@ Select each value that appears in the list and click Apply, and note the CPU usa
         """
 
         if result:
-            self._applySlot(update_template=True)
+            self._applySlot()
         super().done(result)

gns3/dialogs/new_appliance_dialog.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2016 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/>.
+
+from gns3.qt import QtWidgets, QtCore
+from gns3.ui.new_appliance_dialog_ui import Ui_NewApplianceDialog
+from gns3.dialogs.preferences_dialog import PreferencesDialog
+
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class NewApplianceDialog(QtWidgets.QDialog, Ui_NewApplianceDialog):
+    """
+    This dialog allow user to create a new appliance by opening
+    the correct creation dialog
+    """
+
+    def __init__(self, parent):
+
+        super().__init__(parent)
+        self.setupUi(self)
+        self.uiImportApplianceTemplatePushButton.clicked.connect(self._importApplianceTemplatePushButtonClickedSlot)
+        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.Ok).clicked.connect(self._okButtonClickedSlot)
+        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.Cancel).clicked.connect(self.reject)
+        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.Help).clicked.connect(self._helpButtonClickedSlot)
+
+    def _importApplianceTemplatePushButtonClickedSlot(self):
+
+        self.accept()
+        from gns3.main_window import MainWindow
+        MainWindow.instance().openApplianceActionSlot()
+
+    def _okButtonClickedSlot(self):
+
+        self.accept()
+        dialog = PreferencesDialog(self.parent())
+        if self.uiAddIOSRouterRadioButton.isChecked():
+            self._setPreferencesPane(dialog, "Dynamips").uiNewIOSRouterPushButton.clicked.emit(False)
+        elif self.uiAddIOUDeviceRadioButton.isChecked():
+            self._setPreferencesPane(dialog, "IOS on UNIX").uiNewIOUDevicePushButton.clicked.emit(False)
+        elif self.uiAddQemuVMRadioButton.isChecked():
+            self._setPreferencesPane(dialog, "QEMU").uiNewQemuVMPushButton.clicked.emit(False)
+        elif self.uiAddVirtualBoxVMRadioButton.isChecked():
+            self._setPreferencesPane(dialog, "VirtualBox").uiNewVirtualBoxVMPushButton.clicked.emit(False)
+        elif self.uiAddVMwareVMRadioButton.isChecked():
+            self._setPreferencesPane(dialog, "VMware").uiNewVMwareVMPushButton.clicked.emit(False)
+        elif self.uiAddDockerVMRadioButton.isChecked():
+            self._setPreferencesPane(dialog, "Docker").uiNewDockerVMPushButton.clicked.emit(False)
+        else:
+            return
+        dialog.exec_()
+
+    def _helpButtonClickedSlot(self):
+
+        help_text = """<html><p>This dialog helps you to add an appliance template in GNS3. In all cases you must provide your own images.</p>
+        <p>You can download appliance template files (.gns3appliance) from <a href="https://gns3.com/marketplace/appliances">the GNS3 website</a></p>
+        <p>A template file provides community tested settings to run a specific appliance in GNS3.</p></html>
+        """
+        QtWidgets.QMessageBox.information(self, "Help for adding a new appliance template", help_text)
+
+    def _setPreferencesPane(self, dialog, name):
+        """
+        Finds the first child of the QTreeWidgetItem name.
+
+        :param dialog: PreferencesDialog instance
+        :param name: QTreeWidgetItem name
+
+        :returns: current QWidget
+        """
+
+        pane = dialog.uiTreeWidget.findItems(name, QtCore.Qt.MatchFixedString)[0]
+        child_pane = pane.child(0)
+        dialog.uiTreeWidget.setCurrentItem(child_pane)
+        return dialog.uiStackedWidget.currentWidget()
+
+if __name__ == '__main__':
+    import sys
+    app = QtWidgets.QApplication(sys.argv)
+    main = QtWidgets.QMainWindow()
+    dialog = NewApplianceDialog(main, console=True)
+    dialog.show()
+    exit_code = app.exec_()

gns3/dialogs/new_project_dialog.py

@@ -0,0 +1,140 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 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 os
+from ..qt import QtCore, QtGui, QtWidgets
+from ..ui.new_project_dialog_ui import Ui_NewProjectDialog
+
+
+class NewProjectDialog(QtWidgets.QDialog, Ui_NewProjectDialog):
+
+    """
+    New project dialog.
+
+    :param parent: parent widget.
+    :param showed_from_startup: boolean to indicate if this dialog
+    :param default_project_name: Project name by default
+    has been opened automatically when GNS3 started.
+    """
+
+    def __init__(self, parent, showed_from_startup=False, default_project_name="untitled"):
+
+        super().__init__(parent)
+        self.setupUi(self)
+
+        self._main_window = parent
+        self._project_settings = {}
+        self.uiNameLineEdit.setText(default_project_name)
+        self.uiLocationLineEdit.setText(os.path.join(self._main_window.projectsDirPath(), default_project_name))
+
+        self.uiNameLineEdit.textEdited.connect(self._projectNameSlot)
+        self.uiLocationBrowserToolButton.clicked.connect(self._projectPathSlot)
+        self.uiOpenProjectPushButton.clicked.connect(self._openProjectActionSlot)
+        self.uiRecentProjectsPushButton.clicked.connect(self._showRecentProjectsSlot)
+
+        if not showed_from_startup:
+            self.uiOpenProjectPushButton.hide()
+            self.uiRecentProjectsPushButton.hide()
+
+    def keyPressEvent(self, e):
+        """
+        Event handler in order to properly handle escape.
+        """
+
+        if e.key() == QtCore.Qt.Key_Escape:
+            self.close()
+
+    def _projectNameSlot(self, text):
+
+        project_dir = self._main_window.projectsDirPath()
+        if os.path.dirname(self.uiLocationLineEdit.text()) == project_dir:
+            self.uiLocationLineEdit.setText(os.path.join(project_dir, text))
+
+    def _projectPathSlot(self):
+        """
+        Slot to select the a new project location.
+        """
+
+        path, _ = QtWidgets.QFileDialog.getSaveFileName(self, "Project location", os.path.join(self._main_window.projectsDirPath(),
+                                                                                               self.uiNameLineEdit.text()))
+
+        if path:
+            self.uiLocationLineEdit.setText(path)
+
+    def getNewProjectSettings(self):
+
+        return self._project_settings
+
+    def _menuTriggeredSlot(self, action):
+        """
+        Closes this dialog when a recent project
+        has been opened.
+
+        :param action: ignored.
+        """
+
+        self.reject()
+
+    def _openProjectActionSlot(self):
+        """
+        Opens a project and closes this dialog.
+        """
+
+        self._main_window.openProjectActionSlot()
+        self.reject()
+
+    def _showRecentProjectsSlot(self):
+        """
+        lot to show all the recent projects in a menu.
+        """
+
+        menu = QtWidgets.QMenu()
+        menu.triggered.connect(self._menuTriggeredSlot)
+        for action in self._main_window._recent_file_actions:
+            menu.addAction(action)
+        menu.exec_(QtGui.QCursor.pos())
+
+    def done(self, result):
+
+        if result:
+            project_name = self.uiNameLineEdit.text()
+            project_location = self.uiLocationLineEdit.text()
+            project_type = "local"
+
+            if not project_name:
+                QtWidgets.QMessageBox.critical(self, "New project", "Project name is empty")
+                return
+
+            if not project_location:
+                QtWidgets.QMessageBox.critical(self, "New project", "Project location is empty")
+                return
+
+            if os.path.isdir(project_location):
+                reply = QtWidgets.QMessageBox.question(self,
+                                                       "New project",
+                                                       "Location {} already exists, overwrite it?".format(project_location),
+                                                       QtWidgets.QMessageBox.Yes,
+                                                       QtWidgets.QMessageBox.No)
+                if reply == QtWidgets.QMessageBox.No:
+                    return
+
+            self._project_settings["project_name"] = project_name
+            self._project_settings["project_path"] = os.path.join(project_location, project_name + ".gns3")
+            self._project_settings["project_files_dir"] = project_location
+            self._project_settings["project_type"] = project_type
+
+        super().done(result)

gns3/dialogs/new_server_dialog.py

@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 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
+
+from gns3.qt import QtWidgets
+from gns3.ui.new_server_dialog_ui import Ui_NewServerDialog
+from gns3.servers import Servers
+
+
+class NewServerDialog(QtWidgets.QDialog, Ui_NewServerDialog):
+
+    """
+    New server dialog.
+
+    :param parent: parent widget.
+    has been opened automatically when GNS3 started.
+    """
+
+    def __init__(self, parent):
+
+        super().__init__(parent)
+        self.setupUi(self)
+        self.uiEnableAuthenticationCheckBox.stateChanged.connect(self._enableAuthenticationSlot)
+
+    def _enableAuthenticationSlot(self, state):
+        """
+        Slot to enable or not the authentication.
+        """
+
+        if state:
+            self.uiServerUserLineEdit.setEnabled(True)
+            self.uiServerPasswordLineEdit.setEnabled(True)
+        else:
+            self.uiServerUserLineEdit.setEnabled(False)
+            self.uiServerPasswordLineEdit.setEnabled(False)
+
+    def accept(self):
+        """
+        Adds a new remote server.
+        """
+
+        protocol = self.uiServerProtocolComboBox.currentText().lower()
+        host = self.uiServerHostLineEdit.text().strip()
+        port = self.uiServerPortSpinBox.value()
+        if self.uiEnableAuthenticationCheckBox.isChecked():
+            user = self.uiServerUserLineEdit.text().strip()
+            password = self.uiServerPasswordLineEdit.text().strip()
+        else:
+            user = password = ""
+
+        if not re.match(r"^[a-zA-Z0-9\.{}-]+$".format("\u0370-\u1CDF\u2C00-\u30FF\u4E00-\u9FBF"), host):
+            QtWidgets.QMessageBox.critical(self, "Remote server", "Invalid remote server hostname {}".format(host))
+            return
+        if port is None or port < 1:
+            QtWidgets.QMessageBox.critical(self, "Remote server", "Invalid remote server port {}".format(port))
+            return
+
+        servers = Servers.instance()
+        remote_servers = servers.remoteServers()
+
+        # check if the remote server is already defined
+        for server in remote_servers.values():
+            if server.protocol() == protocol and server.host() == host and server.port() == port and server.user() == user:
+                QtWidgets.QMessageBox.critical(self, "Remote server", "Remote server is already defined.")
+                return
+
+        servers.getRemoteServer(protocol, host, port, user, settings={"password": password})
+        servers.save()
+        super().accept()
+
+
+if __name__ == '__main__':
+    import sys
+    app = QtWidgets.QApplication(sys.argv)
+    main = QtWidgets.QMainWindow()
+    dialog = NewServerDialog(main)
+    dialog.show()
+    exit_code = app.exec_()

gns3/dialogs/new_template_wizard.py

@@ -1,288 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2018 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 sys
-import tempfile
-import json
-import os
-
-from ..qt import sip
-from gns3.qt import QtCore, QtWidgets, qpartial
-from gns3.controller import Controller
-from gns3.appliance_manager import ApplianceManager
-
-from ..ui.new_template_wizard_ui import Ui_NewTemplateWizard
-
-import logging
-log = logging.getLogger(__name__)
-
-
-class NewTemplateWizard(QtWidgets.QWizard, Ui_NewTemplateWizard):
-    """
-    New template wizard.
-    """
-
-    def __init__(self, parent):
-
-        super().__init__(parent)
-        self.setupUi(self)
-
-        self.setWizardStyle(QtWidgets.QWizard.WizardStyle.ModernStyle)
-        if sys.platform.startswith("darwin"):
-            # we want to see the cancel button on OSX
-            self.setOptions(QtWidgets.QWizard.WizardOption.NoDefaultButton)
-
-        # add a custom button to show appliance information
-        self.setButtonText(QtWidgets.QWizard.WizardButton.CustomButton1, "&Update from online registry")
-        self.setOption(QtWidgets.QWizard.WizardOption.HaveCustomButton1, True)
-        self.customButtonClicked.connect(self._downloadAppliancesSlot)
-        self.button(QtWidgets.QWizard.WizardButton.CustomButton1).hide()
-        self.uiFilterLineEdit.textChanged.connect(self._filterTextChangedSlot)
-        ApplianceManager.instance().appliances_changed_signal.connect(self._appliancesChangedSlot)
-
-    def _downloadAppliancesSlot(self):
-        """
-        Request server to update appliances from online registry.
-        """
-
-        ApplianceManager.instance().refresh(update=True)
-        Controller.instance().clearStaticCache()
-
-    def _appliancesChangedSlot(self):
-        """
-        Called when the appliances have been updated.
-        """
-
-        self._get_appliances_from_server()
-        QtWidgets.QMessageBox.information(self, "Appliances", "Appliances are up-to-date!")
-
-    def _filterTextChangedSlot(self, text):
-        self._get_appliances_from_server(appliance_filter=text)
-
-    def _setItemIcon(self, item, icon):
-
-        if item is None or sip.isdeleted(item):
-            return
-        item.setIcon(0, icon)
-
-    def _get_tooltip_text(self, appliance):
-        """
-        Gets the appliance information to be displayed in the tooltip.
-        """
-
-        info = (("Product", "product_name"),
-                ("Vendor", "vendor_name"),
-                ("Availability", "availability"),
-                ("Status", "status"),
-                ("Maintainer", "maintainer"))
-
-        if "qemu" in appliance:
-            qemu_info = (("vCPUs", "qemu/cpus"),
-                         ("RAM", "qemu/ram"),
-                         ("Adapters", "qemu/adapters"),
-                         ("Adapter type", "qemu/adapter_type"),
-                         ("Console type", "qemu/console_type"),
-                         ("Architecture", "qemu/arch"),
-                         ("Console type", "qemu/console_type"),
-                         ("KVM", "qemu/kvm"))
-            info = info + qemu_info
-
-        elif "docker" in appliance:
-            docker_info = (("Image", "docker/image"),
-                           ("Adapters", "docker/adapters"),
-                           ("Console type", "docker/console_type"))
-            info = info + docker_info
-
-        elif "iou" in appliance:
-            iou_info = (("RAM", "iou/ram"),
-                        ("NVRAM", "iou/nvram"),
-                        ("Ethernet adapters", "iou/ethernet_adapters"),
-                        ("Serial adapters", "iou/serial_adapters"))
-            info = info + iou_info
-
-        elif "dynamips" in appliance:
-            dynamips_info = (("Platform", "dynamips/platform"),
-                             ("Chassis", "dynamips/chassis"),
-                             ("Midplane", "dynamips/midplane"),
-                             ("NPE", "dynamips/npe"),
-                             ("RAM", "dynamips/ram"),
-                             ("NVRAM", "dynamips/nvram"),
-                             ("slot0", "dynamips/slot0"),
-                             ("slot1", "dynamips/slot1"),
-                             ("slot2", "dynamips/slot2"),
-                             ("slot3", "dynamips/slot3"),
-                             ("slot4", "dynamips/slot4"),
-                             ("slot5", "dynamips/slot5"),
-                             ("slot6", "dynamips/slot6"),
-                             ("wic0", "dynamips/wic0"),
-                             ("wic1", "dynamips/wic1"),
-                             ("wic2", "dynamips/wic2"))
-            info = info + dynamips_info
-
-        text_info = ""
-        for (name, key) in info:
-            if "/" in key:
-                key, subkey = key.split("/")
-                value = appliance.get(key, {}).get(subkey, None)
-            else:
-                value = appliance.get(key, None)
-            if value is None:
-                continue
-            text_info += "<span style='font-weight:bold;'>{}</span>: {}<br>".format(name, value)
-
-        return text_info
-
-    def _get_appliances_from_server(self, appliance_filter=None):
-        """
-        Gets the appliances from the server and display them.
-        """
-
-        self.uiAppliancesTreeWidget.clear()
-        parent_routers = QtWidgets.QTreeWidgetItem(self.uiAppliancesTreeWidget)
-        parent_routers.setText(0, "Routers")
-        parent_routers.setFlags(parent_routers.flags() & ~QtCore.Qt.ItemFlag.ItemIsSelectable)
-        parent_switches = QtWidgets.QTreeWidgetItem(self.uiAppliancesTreeWidget)
-        parent_switches.setText(0, "Switches")
-        parent_switches.setFlags(parent_switches.flags() & ~QtCore.Qt.ItemFlag.ItemIsSelectable)
-        parent_guests = QtWidgets.QTreeWidgetItem(self.uiAppliancesTreeWidget)
-        parent_guests.setText(0, "Guests")
-        parent_guests.setFlags(parent_guests.flags() & ~QtCore.Qt.ItemFlag.ItemIsSelectable)
-        parent_firewalls = QtWidgets.QTreeWidgetItem(self.uiAppliancesTreeWidget)
-        parent_firewalls.setText(0, "Firewalls")
-        parent_firewalls.setFlags(parent_firewalls.flags() & ~QtCore.Qt.ItemFlag.ItemIsSelectable)
-        self.uiAppliancesTreeWidget.expandAll()
-
-        for appliance in ApplianceManager.instance().appliances():
-            if appliance_filter is None:
-                appliance_filter = self.uiFilterLineEdit.text().strip()
-            if appliance_filter and appliance_filter.lower() not in appliance["name"].lower():
-                continue
-
-            if appliance["category"] == "router":
-                item = QtWidgets.QTreeWidgetItem(parent_routers)
-            elif appliance["category"].endswith("switch"):
-                item = QtWidgets.QTreeWidgetItem(parent_switches)
-            elif appliance["category"] == "firewall":
-                item = QtWidgets.QTreeWidgetItem(parent_firewalls)
-            elif appliance["category"] == "guest":
-                item = QtWidgets.QTreeWidgetItem(parent_guests)
-            if appliance["builtin"]:
-                appliance_name = appliance["name"]
-            else:
-                appliance_name = "{} (custom)".format(appliance["name"])
-
-            item.setText(0, appliance_name)
-            #item.setText(1, appliance["category"].capitalize().replace("_", " "))
-
-            if "qemu" in appliance:
-                item.setText(1, "Qemu")
-            elif "iou" in appliance:
-                item.setText(1, "IOU")
-            elif "dynamips" in appliance:
-                item.setText(1, "Dynamips")
-            elif "docker" in appliance:
-                item.setText(1, "Docker")
-            else:
-                item.setText(1, "N/A")
-
-            item.setText(2, appliance["vendor_name"])
-            item.setData(0, QtCore.Qt.ItemDataRole.UserRole, appliance)
-
-            #item.setSizeHint(0, QtCore.QSize(32, 32))
-            item.setToolTip(0, self._get_tooltip_text(appliance))
-            Controller.instance().getSymbolIcon(appliance.get("symbol"), qpartial(self._setItemIcon, item),
-                                                fallback=":/symbols/" + appliance["category"] + ".svg")
-
-        self.uiAppliancesTreeWidget.sortByColumn(0, QtCore.Qt.SortOrder.AscendingOrder)
-        self.uiAppliancesTreeWidget.resizeColumnToContents(0)
-        if not appliance_filter:
-            self.uiAppliancesTreeWidget.collapseAll()
-
-    def initializePage(self, page_id):
-        """
-        Initialize Wizard pages.
-
-        :param page_id: page identifier
-        """
-
-        super().initializePage(page_id)
-        if self.page(page_id) == self.uiApplianceFromServerWizardPage:
-            self.button(QtWidgets.QWizard.WizardButton.CustomButton1).show()
-            self.setButtonText(QtWidgets.QWizard.WizardButton.FinishButton, "&Install")
-            self._get_appliances_from_server()
-        else:
-            self.button(QtWidgets.QWizard.WizardButton.CustomButton1).hide()
-
-    def cleanupPage(self, page_id):
-        """
-        Restore button default settings on the first page.
-        """
-
-        self.button(QtWidgets.QWizard.WizardButton.CustomButton1).hide()
-        self.setButtonText(QtWidgets.QWizard.WizardButton.FinishButton, "&Finish")
-        super().cleanupPage(page_id)
-
-    def validateCurrentPage(self):
-        """
-        Validates if an appliance can be installed.
-        """
-
-        if self.currentPage() == self.uiSelectTemplateSourceWizardPage and not Controller.instance().connected():
-            QtWidgets.QMessageBox.critical(self, "New template", "There is no connection to the server")
-            return False
-        elif self.currentPage() == self.uiApplianceFromServerWizardPage:
-            if not self.uiAppliancesTreeWidget.selectedItems():
-                QtWidgets.QMessageBox.critical(self, "New template", "Please select an appliance to install!")
-                return False
-        return True
-
-    def nextId(self):
-        """
-        Wizard rules!
-        """
-
-        current_id = self.currentId()
-        if self.page(current_id) == self.uiSelectTemplateSourceWizardPage and \
-                (self.uiImportApplianceFromFileRadioButton.isChecked() or self.uiCreateTemplateManuallyRadioButton.isChecked()):
-            self.done(True)
-        return super().nextId()
-
-    def done(self, result):
-        """
-        This dialog is closed.
-        """
-
-        super().done(result)
-        if result:
-            #ApplianceManager.instance().appliances_changed_signal.disconnect(self._appliancesChangedSlot)
-            from gns3.main_window import MainWindow
-            if self.currentPage() == self.uiApplianceFromServerWizardPage:
-                items = self.uiAppliancesTreeWidget.selectedItems()
-                for item in items:
-                    f = tempfile.NamedTemporaryFile(mode="w+", suffix=".builtin.gns3a", delete=False)
-                    json.dump(item.data(0, QtCore.Qt.ItemDataRole.UserRole), f)
-                    f.close()
-                    MainWindow.instance().loadPath(f.name)
-                    try:
-                        os.remove(f.name)
-                    except OSError:
-                        pass
-            elif self.uiCreateTemplateManuallyRadioButton.isChecked():
-                MainWindow.instance().preferencesActionSlot()
-            elif self.uiImportApplianceFromFileRadioButton.isChecked():
-                from gns3.main_window import MainWindow
-                MainWindow.instance().openApplianceActionSlot()

gns3/dialogs/node_info_dialog.py

@@ -1,56 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2018 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/>.
-
-"""
-Dialog to show node information.
-"""
-
-from ..qt import QtWidgets
-from ..ui.node_info_dialog_ui import Ui_NodeInfoDialog
-
-
-class NodeInfoDialog(QtWidgets.QDialog, Ui_NodeInfoDialog):
-
-    """
-    Node information dialog.
-
-    :param parent: parent widget
-    """
-
-    def __init__(self, node, parent):
-
-        super().__init__(parent)
-        self.setupUi(self)
-        general_info = node.info()
-        usage_info = node.usage()
-        command_line_info = node.commandLine()
-        self.setWindowTitle(node.name())
-
-        # General tab
-        self.uiGeneralTextBrowser.setPlainText(general_info)
-
-        # Usage tab
-        if not usage_info:
-            usage_info = "No usage information has been provided for this node."
-        self.uiUsageTextBrowser.setPlainText(usage_info)
-
-        # Command line tab
-        if command_line_info is None:
-            command_line_info = "Command line information is not supported for this type of node."
-        elif len(command_line_info) == 0:
-            command_line_info = "Please start the node in order to get the command line information."
-        self.uiCommandLineTextBrowser.setPlainText(command_line_info)

gns3/dialogs/node_properties_dialog.py

@@ -40,8 +40,8 @@ class NodePropertiesDialog(QtWidgets.QDialog, Ui_NodePropertiesDialog):
         self._node_items = node_items
         self._parent_items = {}
 
-        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Apply).setEnabled(False)
-        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Reset).setEnabled(False)
+        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.Apply).setEnabled(False)
+        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.Reset).setEnabled(False)
 
         self.previousItem = None
         self.previousPage = None
@@ -84,7 +84,7 @@ class NodePropertiesDialog(QtWidgets.QDialog, Ui_NodePropertiesDialog):
             ConfigurationPageItem(self._parent_items[parent], node_item)
 
         # sort the tree
-        self.uiNodesTreeWidget.sortByColumn(0, QtCore.Qt.SortOrder.AscendingOrder)
+        self.uiNodesTreeWidget.sortByColumn(0, QtCore.Qt.AscendingOrder)
 
         if len(self._node_items) == 1:
             parent = " {} group".format(str(node_item.node()))
@@ -93,11 +93,6 @@ class NodePropertiesDialog(QtWidgets.QDialog, Ui_NodePropertiesDialog):
             self.uiNodesTreeWidget.setCurrentItem(item)
             self.showConfigurationPageSlot(item, 0)
             self.splitter.setSizes([0, 600])
-        elif len(self._parent_items) > 0:
-            # We have multiple node we select the first group
-            item = next(iter(self._parent_items.values()))
-            self.uiNodesTreeWidget.setCurrentItem(item)
-            self.showConfigurationPageSlot(item, 0)
 
     def showConfigurationPageSlot(self, item, column):
         """
@@ -135,19 +130,11 @@ class NodePropertiesDialog(QtWidgets.QDialog, Ui_NodePropertiesDialog):
         self.uiConfigStackedWidget.setCurrentWidget(page)
 
         if page != self.uiEmptyPageWidget:
-            self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Apply).setEnabled(True)
-            self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Reset).setEnabled(True)
-            self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Help).setEnabled(True)
+            self.uiButtonBox.button(QtWidgets.QDialogButtonBox.Apply).setEnabled(True)
+            self.uiButtonBox.button(QtWidgets.QDialogButtonBox.Reset).setEnabled(True)
         else:
-            self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Apply).setEnabled(False)
-            self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Reset).setEnabled(False)
-            self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Help).setEnabled(False)
-
-        # hide the contextual help button if there is no help text
-        if page.whatsThis():
-            self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Help).show()
-        else:
-            self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Help).hide()
+            self.uiButtonBox.button(QtWidgets.QDialogButtonBox.Apply).setEnabled(False)
+            self.uiButtonBox.button(QtWidgets.QDialogButtonBox.Reset).setEnabled(False)
 
     def on_uiButtonBox_clicked(self, button):
         """
@@ -157,13 +144,11 @@ class NodePropertiesDialog(QtWidgets.QDialog, Ui_NodePropertiesDialog):
         """
 
         try:
-            if button == self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Apply):
+            if button == self.uiButtonBox.button(QtWidgets.QDialogButtonBox.Apply):
                 self.applySettings()
-            elif button == self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Reset):
+            elif button == self.uiButtonBox.button(QtWidgets.QDialogButtonBox.Reset):
                 self.resetSettings()
-            elif button == self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Help):
-                self.showHelp()
-            elif button == self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Cancel):
+            elif button == self.uiButtonBox.button(QtWidgets.QDialogButtonBox.Cancel):
                 QtWidgets.QDialog.reject(self)
             else:
                 self.applySettings()
@@ -188,10 +173,12 @@ class NodePropertiesDialog(QtWidgets.QDialog, Ui_NodePropertiesDialog):
                 # all children for that group
                 self.previousItem = None
                 self.previousNode = None
+                settings = item.child(0).settings().copy()
                 node = item.child(0).node()
-                settings = page.saveSettings({}, node, group=True)
+                page.saveSettings(settings, node, group=True)
                 for index in range(0, item.childCount()):
                     child = item.child(index)
+                    # child.node().update(settings)  #TODO: delete
                     child.settings().update(settings)
 
         # update the nodes with the settings
@@ -225,14 +212,6 @@ class NodePropertiesDialog(QtWidgets.QDialog, Ui_NodePropertiesDialog):
                 child = item.child(index)
                 child.setSettings(child.node().settings().copy())
 
-    def showHelp(self):
-        """
-        Show contextual help for the current page.
-        """
-
-        page = self.uiConfigStackedWidget.currentWidget()
-        if page != self.uiEmptyPageWidget and page.whatsThis():
-            QtWidgets.QMessageBox.information(self, "{} help".format(page.windowTitle()), page.whatsThis().strip())
 
 class ConfigurationPageItem(QtWidgets.QTreeWidgetItem):
 

gns3/dialogs/notif_dialog.py

@@ -1,190 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2016 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/>.
-
-"""
-Display error to the user in an overlay popup
-"""
-
-import time
-
-from gns3.qt import QtWidgets, QtCore, qslot
-
-import logging
-log = logging.getLogger(__name__)
-
-
-MAX_ELEMENTS = 3
-DISPLAY_DURATION = {
-    "CRITICAL": 120,
-    "ERROR": 120,
-    "WARNING": 20,
-    "INFO": 5
-}
-
-
-class NotifDialogHandler(logging.StreamHandler):
-
-    def __init__(self, dialog):
-        super().__init__()
-        self._dialog = dialog
-        self.setLevel(logging.INFO)
-        self._dialog.show()
-
-    def emit(self, record):
-        self._dialog.addNotif(record.levelname, record.getMessage())
-
-
-class NotifDialog(QtWidgets.QWidget):
-
-    def __init__(self, parent):
-        super().__init__(parent)
-        self._notifs = []
-
-        self.setWindowFlags(QtCore.Qt.WindowType.FramelessWindowHint |
-                            QtCore.Qt.WindowType.WindowDoesNotAcceptFocus |
-                            QtCore.Qt.WindowType.SubWindow)
-        # QtCore.Qt.WindowType.Tool)
-        # QtCore.Qt.WindowType.WindowStaysOnTopHint)
-        self.setAttribute(QtCore.Qt.WidgetAttribute.WA_ShowWithoutActivating)  # | QtCore.Qt.WidgetAttribute.WA_TranslucentBackground)
-
-        self._layout = QtWidgets.QVBoxLayout()
-
-        self._timer = QtCore.QTimer()
-        self._timer.setInterval(1000)
-        self._timer.timeout.connect(self._refreshSlot)
-        self._timer.start()
-
-        for i in range(0, MAX_ELEMENTS):
-            l = QtWidgets.QLabel()
-            l.setAlignment(QtCore.Qt.AlignmentFlag.AlignTop)
-            l.setWordWrap(True)
-            l.hide()
-            self._layout.addWidget(l)
-        self.setLayout(self._layout)
-
-    @qslot
-    def addNotif(self, level, message):
-        if not self.parent().settings().get("overlay_notifications", True):
-            return
-
-        # This unicode char prevent the wordwrap at /
-        message = message.replace("/", "\u2060/\u2060")
-        if len(self._notifs) == MAX_ELEMENTS:
-            self._notifs.pop(0)
-        self._notifs.append((level, message, time.time()))
-        self.update()
-
-    @qslot
-    def _refreshSlot(self):
-        """
-        Hide the notifs after some delay
-        """
-        notifs = []
-        for (i, (level, message, when)) in enumerate(self._notifs):
-            if when + DISPLAY_DURATION[level] > time.time():
-                notifs.append((level, message, when))
-        if notifs != self._notifs:
-            self._notifs = notifs
-            self.update()
-        elif len(notifs) > 0:
-            self.resize()
-
-    def update(self):
-        if len(self._notifs) == 0:
-            self.hide()
-        else:
-            for (i, (level, message, when)) in enumerate(self._notifs):
-                w = self._layout.itemAt(i).widget()
-                w.setText(message)
-                if level == "ERROR" or level == "CRITICAL":
-                    w.setStyleSheet("""
-                        color: black;
-                        padding-left: 12px;
-                        background-color: rgb(247, 205, 198);
-                        border-left: 10px solid red;
-                    """)
-                elif level == "WARNING":
-                    w.setStyleSheet("""
-                        color: black;
-                        padding-left: 12px;
-                        background-color: #f4f2b5;
-                        border-left: 10px solid orange;
-                    """)
-                elif level == "INFO":
-                    w.setStyleSheet("""
-                        color: black;
-                        padding-left: 12px;
-                        background-color: #cfffc9;
-                        border-left: 10px solid green;
-                    """)
-
-                w.show()
-            for i in range(i + 1, MAX_ELEMENTS):
-                w = self._layout.itemAt(i).widget()
-                w.hide()
-
-            self.resize()
-            self.show()
-
-    def resize(self):
-        x = self.parent().width() - self.width() - 10
-        y = 10
-        self.setGeometry(x, y, self.sizeHint().width(), self.sizeHint().height())
-
-    @qslot
-    def mousePressEvent(self, event):
-        self._notifs.clear()
-        self.update()
-
-
-if __name__ == '__main__':
-    """
-    A demo main for testing the features
-    """
-    import sys
-    app = QtWidgets.QApplication(sys.argv)
-    logging.basicConfig(level=logging.INFO)
-
-    class MainWindow(QtWidgets.QWidget):
-
-        def __init__(self):
-            super().__init__()
-            l1 = QtWidgets.QLabel()
-            l1.setText("Hello World")
-
-            vbox = QtWidgets.QVBoxLayout()
-            vbox.addWidget(l1)
-            self.setLayout(vbox)
-            self.setStyleSheet("background-color:blue;")
-            self._dialog = NotifDialog(self)
-            log.addHandler(NotifDialogHandler(self._dialog))
-            log.info("test")
-
-        def moveEvent(self, event):
-            log.error("An error")
-            log.info("An info with an url http://test")
-            log.warning("A warning with a long long long longlong longlong longlong longlong longlong longlong longlong long message")
-            self._dialog.update()
-
-        def resizeEvent(self, event):
-            self._dialog.update()
-
-    main = MainWindow()
-    main.setMinimumWidth(600)
-    main.setMinimumHeight(600)
-    main.show()
-    exit_code = app.exec()

gns3/dialogs/preferences_dialog.py

@@ -19,17 +19,13 @@
 Dialog to load module and built-in preference pages.
 """
 
-from ..qt import QtGui, QtCore, QtWidgets
+from ..qt import QtCore, QtWidgets
 from ..ui.preferences_dialog_ui import Ui_PreferencesDialog
 from ..pages.server_preferences_page import ServerPreferencesPage
 from ..pages.general_preferences_page import GeneralPreferencesPage
 from ..pages.packet_capture_preferences_page import PacketCapturePreferencesPage
-from ..pages.gns3_vm_preferences_page import GNS3VMPreferencesPage
 from ..modules import MODULES
 
-import logging
-log = logging.getLogger(__name__)
-
 
 class PreferencesDialog(QtWidgets.QDialog, Ui_PreferencesDialog):
 
@@ -44,14 +40,12 @@ class PreferencesDialog(QtWidgets.QDialog, Ui_PreferencesDialog):
         super().__init__(parent)
 
         self.setupUi(self)
-        self._modified_pages = set()
 
         # We adapt the max size to the screen resolution
         # We need to manually do that otherwise on small screen the windows
         # could be bigger than the screen instead of displaying scrollbars
-        geometry = QtGui.QGuiApplication.primaryScreen().geometry()
-        height = geometry.height() - 100
-        width = geometry.width() - 100
+        height = QtWidgets.QDesktopWidget().screenGeometry().height() - 100
+        width = QtWidgets.QDesktopWidget().screenGeometry().width() - 100
 
         # 980 is the default width
         if self.width() > width:
@@ -61,7 +55,7 @@ class PreferencesDialog(QtWidgets.QDialog, Ui_PreferencesDialog):
             self.resize(self.width(), height)
 
         self.uiTreeWidget.currentItemChanged.connect(self._showPreferencesPageSlot)
-        self._applyButton = self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Apply)
+        self._applyButton = self.uiButtonBox.button(QtWidgets.QDialogButtonBox.Apply)
         self._applyButton.clicked.connect(self._applyPreferences)
         self._applyButton.setEnabled(False)
         self._applyButton.setStyleSheet("QPushButton:disabled {color: gray}")
@@ -74,8 +68,8 @@ class PreferencesDialog(QtWidgets.QDialog, Ui_PreferencesDialog):
         # set the maximum width based on the content of column 0
         self.uiTreeWidget.setMaximumWidth(self.uiTreeWidget.sizeHintForColumn(0) + 10)
 
-        # Something has changed?
-        self._modified_pages = set()
+        # Something has change?
+        self._modified = False
 
     def _loadPreferencePages(self):
         """
@@ -86,7 +80,6 @@ class PreferencesDialog(QtWidgets.QDialog, Ui_PreferencesDialog):
         pages = [
             GeneralPreferencesPage,
             ServerPreferencesPage,
-            GNS3VMPreferencesPage,
             PacketCapturePreferencesPage,
         ]
 
@@ -96,7 +89,7 @@ class PreferencesDialog(QtWidgets.QDialog, Ui_PreferencesDialog):
             name = preferences_page.windowTitle()
             item = QtWidgets.QTreeWidgetItem(self.uiTreeWidget)
             item.setText(0, name)
-            item.setData(0, QtCore.Qt.ItemDataRole.UserRole, preferences_page)
+            item.setData(0, QtCore.Qt.UserRole, preferences_page)
             self.uiStackedWidget.addWidget(preferences_page)
             self._items.append(item)
             self._watchForChanges(preferences_page)
@@ -107,12 +100,11 @@ class PreferencesDialog(QtWidgets.QDialog, Ui_PreferencesDialog):
             parent = self.uiTreeWidget
             for cls in preference_pages:
                 preferences_page = cls()
-                preferences_page.setParent(self)
                 preferences_page.loadPreferences()
                 name = preferences_page.windowTitle()
                 item = QtWidgets.QTreeWidgetItem(parent)
                 item.setText(0, name)
-                item.setData(0, QtCore.Qt.ItemDataRole.UserRole, preferences_page)
+                item.setData(0, QtCore.Qt.UserRole, preferences_page)
                 self.uiStackedWidget.addWidget(preferences_page)
                 self._items.append(item)
                 if cls is preference_pages[0]:
@@ -130,9 +122,7 @@ class PreferencesDialog(QtWidgets.QDialog, Ui_PreferencesDialog):
         # Class name, changed signal
         widget_to_watch = {
             QtWidgets.QLineEdit: "textChanged",
-            QtWidgets.QPlainTextEdit: "textChanged",
-            # QtWidgets.QTreeWidget: "itemChanged",
-            QtWidgets.QTreeWidget: "itemDoubleClicked",
+            QtWidgets.QTreeWidget: "itemChanged",
             QtWidgets.QComboBox: "currentIndexChanged",
             QtWidgets.QSpinBox: "valueChanged",
             QtWidgets.QAbstractButton: "pressed"
@@ -144,27 +134,10 @@ class PreferencesDialog(QtWidgets.QDialog, Ui_PreferencesDialog):
 
     def _preferenceChangeSlot(self, *args):
         """
-        Called when something change in the preference dialog
+        Called when somthing change in the preference dialog
         """
-
-        # Found the page with the change
-        widget = sender = self.sender()
-        while widget.parent() != self.uiStackedWidget:
-            widget = widget.parent()
-
-        if self.addModifiedPage(widget):
-            log.debug("%s value has changed", sender.objectName())
-
-    def addModifiedPage(self, widget):
-        """
-        :returns: True is the page is initialized and element added
-        """
-        # The widget can trigger signal before the end of init due to async api call
-        if not hasattr(widget, 'pageInitialized') or widget.pageInitialized():
-            self._applyButton.setEnabled(True)
-            self._modified_pages.add(widget)
-            return True
-        return False
+        self._applyButton.setEnabled(True)
+        self._modified = True
 
     def _showPreferencesPageSlot(self, current, previous):
         """
@@ -177,7 +150,7 @@ class PreferencesDialog(QtWidgets.QDialog, Ui_PreferencesDialog):
         if current is None:
             current = previous
 
-        preferences_page = current.data(0, QtCore.Qt.ItemDataRole.UserRole)
+        preferences_page = current.data(0, QtCore.Qt.UserRole)
         accessible_name = preferences_page.accessibleName()
         if accessible_name:
             self.uiTitleLabel.setText(accessible_name)
@@ -186,31 +159,25 @@ class PreferencesDialog(QtWidgets.QDialog, Ui_PreferencesDialog):
             self.uiTitleLabel.setText("{} preferences".format(name))
         index = self.uiStackedWidget.indexOf(preferences_page)
         widget = self.uiStackedWidget.widget(index)
-        #self.uiStackedWidget.setMinimumSize(widget.size())  # FIXME: this seems to not work on Windows and OSX
-        #self.uiStackedWidget.resize(widget.size())
+        #self.uiStackedWidget.setMinimumSize(widget.size())
+        self.uiStackedWidget.resize(widget.size())
         self.uiStackedWidget.setCurrentIndex(index)
 
-        for index in range(0, self.uiStackedWidget.count()):
-            page = self.uiStackedWidget.widget(index)
-            if self.uiStackedWidget.currentIndex() == index:
-                page.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Expanding)
-            else:
-                page.setSizePolicy(QtWidgets.QSizePolicy.Policy.Ignored, QtWidgets.QSizePolicy.Policy.Ignored)
-
     def _applyPreferences(self):
         """
         Saves all the preferences.
         """
 
         success = True
-        for preferences_page in list(self._modified_pages):
+        for item in self._items:
+            preferences_page = item.data(0, QtCore.Qt.UserRole)
             ok = preferences_page.savePreferences()
             # if page.savePreferences() returns None, assume success
             if ok is not None and not ok:
                 success = False
         if success:
             self._applyButton.setEnabled(False)
-            self._modified_pages = set()
+            self._modified = False
         return success
 
     def reject(self):
@@ -218,15 +185,13 @@ class PreferencesDialog(QtWidgets.QDialog, Ui_PreferencesDialog):
         Closes this dialog.
         """
 
-        if len(self._modified_pages) > 0:
-            # Get the title of pages with modifications
-            pages_title = ', '.join([page.windowTitle() for page in self._modified_pages])
+        if self._modified:
             reply = QtWidgets.QMessageBox.warning(self,
                                                   "Preferences",
-                                                  "You have unsaved preferences in {}.\n\nContinue without saving?".format(pages_title),
-                                                  QtWidgets.QMessageBox.StandardButton.Yes,
-                                                  QtWidgets.QMessageBox.StandardButton.No)
-            if reply == QtWidgets.QMessageBox.StandardButton.No:
+                                                  "You have unsaved preferences.\n\nContinue without saving?",
+                                                  QtWidgets.QMessageBox.Yes,
+                                                  QtWidgets.QMessageBox.No)
+            if reply == QtWidgets.QMessageBox.No:
                 return
         QtWidgets.QDialog.reject(self)
 
@@ -235,5 +200,11 @@ class PreferencesDialog(QtWidgets.QDialog, Ui_PreferencesDialog):
         Saves the preferences and closes this dialog.
         """
 
+        # close the nodes dock to refresh the node list
+        from ..main_window import MainWindow
+        main_window = MainWindow.instance()
+        main_window.uiNodesDockWidget.setVisible(False)
+        main_window.uiNodesDockWidget.setWindowTitle("")
+
         if self._applyPreferences():
             QtWidgets.QDialog.accept(self)

gns3/dialogs/profile_select.py

@@ -1,112 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2016 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 os
-import sys
-import shutil
-
-from gns3.qt import QtWidgets, QtGui
-from gns3.local_config import LocalConfig
-from gns3.ui.profile_select_dialog_ui import Ui_ProfileSelectDialog
-from gns3.version import __version_info__
-
-import logging
-log = logging.getLogger(__name__)
-
-
-class ProfileSelectDialog(QtWidgets.QDialog, Ui_ProfileSelectDialog):
-    """
-    This dialog allow user to choose a profile of settings
-    """
-
-    def __init__(self, parent=None):
-
-        if parent is None:
-            self._main = QtWidgets.QMainWindow()
-            self._main.hide()
-            parent = self._main
-        super().__init__(parent)
-
-        self.setupUi(self)
-        self.uiNewPushButton.clicked.connect(self._newPushButtonSlot)
-        self.uiDeletePushButton.clicked.connect(self._deletePushButtonSlot)
-
-        # Center on screen
-        screen = QtGui.QGuiApplication.primaryScreen().geometry()
-        self.move(screen.center() - self.rect().center())
-
-        version = "{}.{}".format(__version_info__[0], __version_info__[1])
-        if sys.platform.startswith("win"):
-            appdata = os.path.expandvars("%APPDATA%")
-            path = os.path.join(appdata, "GNS3", version)
-        else:
-            xgd_config_var = "$XDG_CONFIG_HOME"
-            xdg_config_res = os.path.expandvars(xgd_config_var)
-            if xdg_config_res != xgd_config_var:
-                path = os.path.join(xdg_config_res, "GNS3", version)
-            else:
-                home = os.path.expanduser("~")
-                path = os.path.join(home, ".config", "GNS3", version)
-
-        self.profiles_path = os.path.join(path, "profiles")
-
-        self.uiShowAtStartupCheckBox.setChecked(LocalConfig.instance().multiProfiles())
-        self._refresh()
-
-    def _refresh(self):
-        self.uiProfileSelectComboBox.clear()
-        self.uiProfileSelectComboBox.addItem("default")
-
-        try:
-            if os.path.exists(self.profiles_path):
-                for profile in sorted(os.listdir(self.profiles_path)):
-                    if not profile.startswith("."):
-                        self.uiProfileSelectComboBox.addItem(profile)
-        except OSError:
-            pass
-
-    def profile(self):
-        return self.uiProfileSelectComboBox.currentText()
-
-    def accept(self):
-        LocalConfig.instance().setMultiProfiles(self.uiShowAtStartupCheckBox.isChecked())
-        super().accept()
-
-    def _newPushButtonSlot(self):
-        profile, ok = QtWidgets.QInputDialog.getText(self, "New profile", "Profile name:")
-        if ok:
-            self.uiProfileSelectComboBox.addItem(profile)
-            self.uiProfileSelectComboBox.setCurrentText(profile)
-            self.accept()
-
-    def _deletePushButtonSlot(self):
-        profile = self.uiProfileSelectComboBox.currentText()
-        if profile == "default":
-            QtWidgets.QMessageBox.critical(self, "Delete profile", "The default profile cannot be deleted")
-        else:
-            try:
-                shutil.rmtree(os.path.join(self.profiles_path, profile))
-                self._refresh()
-            except (OSError, PermissionError) as e:
-                QtWidgets.QMessageBox.critical(self, "Cannot delete profile", str(e))
-
-
-if __name__ == '__main__':
-    app = QtWidgets.QApplication(sys.argv)
-    dialog = ProfileSelectDialog()
-    dialog.show()
-    exit_code = app.exec()

gns3/dialogs/project_dialog.py

@@ -1,318 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2014 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 os
-from ..qt import QtCore, QtGui, QtWidgets, qslot, sip_is_deleted
-from ..ui.project_dialog_ui import Ui_ProjectDialog
-from ..controller import Controller
-from ..topology import Topology
-
-
-import logging
-log = logging.getLogger(__name__)
-
-
-class ProjectDialog(QtWidgets.QDialog, Ui_ProjectDialog):
-
-    """
-    New project dialog.
-    """
-
-    def __init__(self, parent, default_project_name="untitled", show_open_options=True):
-        """
-        :param parent: parent widget.
-        :param default_project_name: Project name by default
-        :param show_open_options: If true allow to open a project from the dialog
-        otherwise it's just for create a project
-        """
-        super().__init__(parent)
-        self.setupUi(self)
-
-        self._main_window = parent
-        self._project_settings = {}
-        self.uiNameLineEdit.setText(default_project_name)
-        self.uiLocationLineEdit.setText(os.path.join(Topology.instance().projectsDirPath(), default_project_name))
-
-        self.uiNameLineEdit.textEdited.connect(self._projectNameSlot)
-        self.uiLocationBrowserToolButton.clicked.connect(self._projectPathSlot)
-        self.uiSettingsPushButton.clicked.connect(self._settingsClickedSlot)
-
-        if show_open_options:
-            self.uiOpenProjectPushButton.clicked.connect(self._openProjectActionSlot)
-            self._addRecentFilesMenu()
-        else:
-            self.uiOpenProjectGroupBox.hide()
-            self.uiProjectTabWidget.removeTab(1)
-
-        # If the controller is remote we hide option for local file system
-        if Controller.instance().isRemote():
-            self.uiLocationLabel.setVisible(False)
-            self.uiLocationLineEdit.setVisible(False)
-            self.uiLocationBrowserToolButton.setVisible(False)
-            self.uiOpenProjectPushButton.setVisible(False)
-
-        self.uiProjectsTreeWidget.itemDoubleClicked.connect(self._projectsTreeWidgetDoubleClickedSlot)
-        self.uiDeleteProjectButton.clicked.connect(self._deleteProjectSlot)
-        self.uiDuplicateProjectPushButton.clicked.connect(self._duplicateProjectSlot)
-        self.uiRefreshProjectsPushButton.clicked.connect(Controller.instance().refreshProjectList)
-        Controller.instance().project_list_updated_signal.connect(self._updateProjectListSlot)
-        self._updateProjectListSlot()
-        Controller.instance().refreshProjectList()
-
-    def _settingsClickedSlot(self):
-        """
-        When the user click on the settings button
-        """
-        self.reject()
-        self._main_window.preferencesActionSlot()
-
-    def _projectsTreeWidgetDoubleClickedSlot(self, item, column):
-        self.done(True)
-
-    @qslot
-    def _deleteProjectSlot(self, *args):
-        if len(self.uiProjectsTreeWidget.selectedItems()) == 0:
-            QtWidgets.QMessageBox.critical(self, "Delete project", "No project selected")
-            return
-
-        projects_to_delete = set()
-        for project in self.uiProjectsTreeWidget.selectedItems():
-            if sip_is_deleted(project):
-                continue
-            project_id = project.data(0, QtCore.Qt.ItemDataRole.UserRole)
-            project_name = project.data(1, QtCore.Qt.ItemDataRole.UserRole)
-
-            reply = QtWidgets.QMessageBox.warning(self,
-                                                  "Delete project",
-                                                  'Delete project "{}"?\nThis cannot be reverted.'.format(project_name),
-                                                  QtWidgets.QMessageBox.StandardButton.Yes,
-                                                  QtWidgets.QMessageBox.StandardButton.No)
-            if reply == QtWidgets.QMessageBox.StandardButton.Yes:
-                projects_to_delete.add(project_id)
-
-        for project_id in projects_to_delete:
-            Controller.instance().deleteProject(project_id)
-
-    def _duplicateProjectSlot(self):
-
-        if len(self.uiProjectsTreeWidget.selectedItems()) == 0:
-            QtWidgets.QMessageBox.critical(self, "Duplicate project", "No project selected")
-            return
-
-        if len(self.uiProjectsTreeWidget.selectedItems()) > 1:
-            QtWidgets.QMessageBox.critical(self, "Duplicate project", "Please select only one project to duplicate")
-            return
-
-        for project in self.uiProjectsTreeWidget.selectedItems():
-            project_id = project.data(0, QtCore.Qt.ItemDataRole.UserRole)
-            project_name = project.data(1, QtCore.Qt.ItemDataRole.UserRole)
-
-            new_project_name = project_name + "-1"
-            existing_project_name = [p["name"] for p in Controller.instance().projects()]
-            i = 1
-            while new_project_name in existing_project_name:
-                new_project_name = "{}-{}".format(project_name, i)
-                i += 1
-
-            name, reply = QtWidgets.QInputDialog.getText(self,
-                                                         "Duplicate project",
-                                                         'Duplicate project "{}"?.'.format(project_name),
-                                                         QtWidgets.QLineEdit.EchoMode.Normal,
-                                                         new_project_name)
-            name = name.strip()
-            if reply and len(name) > 0:
-
-                reset_mac_addresses = self.uiResetMacAddressesCheckBox.isChecked()
-
-                if Controller.instance().isRemote():
-                    Controller.instance().post("/projects/{project_id}/duplicate".format(project_id=project_id),
-                                               self._duplicateCallback,
-                                               body={"name": name, "reset_mac_addresses": reset_mac_addresses},
-                                               progressText="Duplicating project '{}'...".format(name),
-                                               timeout=None)
-                else:
-                    project_location = os.path.join(Topology.instance().projectsDirPath(), name)
-                    Controller.instance().post("/projects/{project_id}/duplicate".format(project_id=project_id),
-                                               self._duplicateCallback,
-                                               body={"name": name, "path": project_location, "reset_mac_addresses": reset_mac_addresses},
-                                               progressText="Duplicating project '{}'...".format(name),
-                                               timeout=None)
-
-    def _duplicateCallback(self, result, error=False, **kwargs):
-        if error:
-            log.error("Error while duplicating project: {}".format(result["message"]))
-            return
-        Controller.instance().refreshProjectList()
-
-    @qslot
-    def _updateProjectListSlot(self, *args):
-        self.uiProjectsTreeWidget.clear()
-        self.uiDeleteProjectButton.setEnabled(False)
-        self.uiProjectsTreeWidget.setUpdatesEnabled(False)
-        items = []
-        for project in Controller.instance().projects():
-            path = os.path.join(project["path"], project["filename"])
-            item = QtWidgets.QTreeWidgetItem([project["name"], project["status"], path])
-            item.setData(0, QtCore.Qt.ItemDataRole.UserRole, project["project_id"])
-            item.setData(1, QtCore.Qt.ItemDataRole.UserRole, project["name"])
-            item.setData(2, QtCore.Qt.ItemDataRole.UserRole, path)
-            items.append(item)
-        self.uiProjectsTreeWidget.addTopLevelItems(items)
-
-        if len(Controller.instance().projects()):
-            self.uiDeleteProjectButton.setEnabled(True)
-
-        self.uiProjectsTreeWidget.header().setResizeContentsPrecision(100)  # How many row is checked for the resize for performance reason
-        self.uiProjectsTreeWidget.resizeColumnToContents(0)
-        self.uiProjectsTreeWidget.resizeColumnToContents(1)
-        self.uiProjectsTreeWidget.resizeColumnToContents(2)
-        self.uiProjectsTreeWidget.sortItems(0, QtCore.Qt.SortOrder.AscendingOrder)
-        self.uiProjectsTreeWidget.setUpdatesEnabled(True)
-
-    def keyPressEvent(self, e):
-        """
-        Event handler in order to properly handle escape.
-        """
-
-        if e.key() == QtCore.Qt.Key.Key_Escape:
-            self.close()
-
-    def _projectNameSlot(self, text):
-
-        project_dir = Topology.instance().projectsDirPath()
-        if os.path.dirname(self.uiLocationLineEdit.text()) == project_dir:
-            self.uiLocationLineEdit.setText(os.path.join(project_dir, text))
-
-    def _projectPathSlot(self):
-        """
-        Slot to select the a new project location.
-        """
-
-        path, _ = QtWidgets.QFileDialog.getSaveFileName(self, "Project location", os.path.join(Topology.instance().projectsDirPath(),
-                                                                                               self.uiNameLineEdit.text()))
-
-        if path:
-            self.uiNameLineEdit.setText(os.path.basename(path))
-            self.uiLocationLineEdit.setText(path)
-
-    def getProjectSettings(self):
-
-        return self._project_settings
-
-    def _menuTriggeredSlot(self, action):
-        """
-        Closes this dialog when a recent project
-        has been opened.
-
-        :param action: ignored.
-        """
-
-        self.reject()
-
-    def _openProjectActionSlot(self):
-        """
-        Opens a project and closes this dialog.
-        """
-
-        self._main_window.openProjectActionSlot()
-        self.reject()
-
-    def _addRecentFilesMenu(self):
-        """
-        Add recent projects in a menu.
-        """
-
-        menu = QtWidgets.QMenu(parent=self)
-        if Controller.instance().isRemote():
-            for action in self._main_window.recent_project_actions:
-                menu.addAction(action)
-        else:
-            for action in self._main_window.recent_file_actions:
-                menu.addAction(action)
-        menu.triggered.connect(self._menuTriggeredSlot)
-        self.uiRecentProjectsPushButton.setMenu(menu)
-
-    def _overwriteProjectCallback(self, result, error=False, **kwargs):
-        if error:
-            # A 404 could arrive if someone else as deleted the project
-            if "status" not in result or result["status"] != 404:
-                return
-            elif "message" in result:
-                QtWidgets.QMessageBox.critical(self,
-                                               "New Project",
-                                               "Error while overwrite project: {}".format(result["message"]))
-        Controller.instance().refreshProjectList()
-        self.done(True)
-
-    def _newProject(self):
-        self._project_settings["project_name"] = self.uiNameLineEdit.text().strip()
-        if Controller.instance().isRemote():
-            self._project_settings.pop("project_path", None)
-            self._project_settings.pop("project_files_dir", None)
-        else:
-            project_location = self.uiLocationLineEdit.text().strip()
-            if not project_location:
-                QtWidgets.QMessageBox.critical(self, "New project", "Project location is empty")
-                return False
-
-            self._project_settings["project_path"] = os.path.join(project_location, self._project_settings["project_name"] + ".gns3")
-            self._project_settings["project_files_dir"] = project_location
-
-        if len(self._project_settings["project_name"]) == 0:
-            QtWidgets.QMessageBox.critical(self, "New project", "Project name is empty")
-            return False
-
-        for existing_project in Controller.instance().projects():
-            if self._project_settings["project_name"] == existing_project["name"] \
-               and ("project_files_dir" in self._project_settings and self._project_settings["project_files_dir"] == existing_project["path"]):
-
-                if existing_project["status"] == "opened":
-                    QtWidgets.QMessageBox.critical(self,
-                                                   "New project",
-                                                   'Project "{}" is opened, it cannot be overwritten'.format(self._project_settings["project_name"]))
-                    return False
-
-                reply = QtWidgets.QMessageBox.warning(self,
-                                                      "New project",
-                                                      'Project "{}" already exists in location "{}", overwrite it?'.format(existing_project["name"], existing_project["path"]),
-                                                      QtWidgets.QMessageBox.StandardButton.Yes,
-                                                      QtWidgets.QMessageBox.StandardButton.No)
-
-                if reply == QtWidgets.QMessageBox.StandardButton.Yes:
-                    Controller.instance().deleteProject(existing_project["project_id"], self._overwriteProjectCallback)
-
-                # In all cases we cancel the new project and if project success to delete
-                # we will call done again
-                return False
-
-        return True
-
-    def done(self, result):
-
-        if result:
-            if self.uiProjectTabWidget.currentIndex() == 0:
-                if not self._newProject():
-                    return
-            else:
-                current = self.uiProjectsTreeWidget.currentItem()
-                if current is None:
-                    QtWidgets.QMessageBox.critical(self, "Open project", "No project selected")
-                    return
-
-                self._project_settings["project_id"] = current.data(0, QtCore.Qt.ItemDataRole.UserRole)
-                self._project_settings["project_name"] = current.data(1, QtCore.Qt.ItemDataRole.UserRole)
-        super().done(result)

gns3/dialogs/project_export_wizard.py

@@ -1,144 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2018 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 sys
-import os
-import datetime
-
-from gns3.qt import QtCore, QtWidgets
-from ..local_server import LocalServer
-from ..utils.progress_dialog import ProgressDialog
-from ..utils.export_project_worker import ExportProjectWorker
-from ..ui.export_project_wizard_ui import Ui_ExportProjectWizard
-
-import logging
-log = logging.getLogger(__name__)
-
-
-class ExportProjectWizard(QtWidgets.QWizard, Ui_ExportProjectWizard):
-    """
-    Export project wizard.
-    """
-
-    def __init__(self, project, parent):
-
-        super().__init__(parent)
-        self.setupUi(self)
-
-        self._project = project
-        self._path = None
-        self.setWizardStyle(QtWidgets.QWizard.WizardStyle.ModernStyle)
-        if sys.platform.startswith("darwin"):
-            # we want to see the cancel button on OSX
-            self.setOptions(QtWidgets.QWizard.WizardOption.NoDefaultButton)
-
-        self.uiCompressionComboBox.addItem("None", "none")
-        self.uiCompressionComboBox.addItem("Zip compression (deflate)", "zip")
-        self.uiCompressionComboBox.addItem("Bzip2 compression", "bzip2")
-        self.uiCompressionComboBox.addItem("Lzma compression", "lzma")
-
-        # set zip compression by default
-        self.uiCompressionComboBox.setCurrentIndex(1)
-        self.helpRequested.connect(self._showHelpSlot)
-        self.uiPathBrowserToolButton.clicked.connect(self._pathBrowserSlot)
-        self._loadReadme()
-
-    def _loadReadme(self):
-
-        self._project.get("/files/README.txt", self._loadedReadme)
-
-    def _loadedReadme(self, result, error=False, raw_body=None, context={}, **kwargs):
-
-        if not error:
-            self.uiReadmeTextEdit.setPlainText(raw_body.decode("utf-8", errors="replace"))
-        else:
-            readme_text = "Project: '{}' created on {}\nAuthor: John Doe <john.doe@example.com>\n\nNo project description was given".format(self._project.name(), datetime.date.today())
-            self.uiReadmeTextEdit.setPlainText(readme_text)
-
-    def _pathBrowserSlot(self):
-
-        directory = QtCore.QStandardPaths.writableLocation(QtCore.QStandardPaths.StandardLocation.DocumentsLocation)
-        if len(directory) == 0:
-            directory = LocalServer.instance().localServerSettings()["projects_path"]
-
-        path, _ = QtWidgets.QFileDialog.getSaveFileName(self, "Export portable project", directory,
-                                                        "GNS3 Portable Project (*.gns3project *.gns3p)",
-                                                        "GNS3 Portable Project (*.gns3project *.gns3p)")
-        if path is None or len(path) == 0:
-            return
-
-        self.uiPathLineEdit.setText(path)
-
-    def _showHelpSlot(self):
-
-        include_image_help = """Including base images means additional images will not be requested to
-        import the project on another computer, however the resulting file will be much bigger.
-        Also, you are responsible to check if you have the right to distribute the image(s) as part of the project.
-        """
-        QtWidgets.QMessageBox.information(self, "Help about export a project", include_image_help)
-
-    def validateCurrentPage(self):
-        """
-        Validates if the project can be exported.
-        """
-
-        if self.currentPage() == self.uiExportOptionsWizardPage:
-            path = self.uiPathLineEdit.text().strip()
-            if not path:
-                QtWidgets.QMessageBox.critical(self, "Export project", "Please select a path where to export the project")
-                return False
-
-            if not path.endswith(".gns3project") and not path.endswith(".gns3p"):
-                path += ".gns3project"
-            try:
-                open(path, 'wb+').close()
-            except OSError as e:
-                QtWidgets.QMessageBox.critical(self, "Export project", "Cannot export project to '{}': {}".format(path, e))
-                return False
-            self._path = path
-        elif self.currentPage() == self.uiProjectReadmeWizardPage:
-            text = self.uiReadmeTextEdit.toPlainText().strip()
-            if text:
-                self._project.post("/files/README.txt", self._saveReadmeCallback, body=text)
-        return True
-
-    def _saveReadmeCallback(self, result, error=False, **kwargs):
-        if error:
-            QtWidgets.QMessageBox.critical(self, "Export project", "Could not created readme file")
-
-    def done(self, result):
-        """
-        This dialog is closed.
-        """
-
-        if result:
-            include_images = include_snapshots = reset_mac_addresses = keep_compute_ids = "no"
-            if self.uiIncludeImagesCheckBox.isChecked():
-                include_images = "yes"
-            if self.uiIncludeSnapshotsCheckBox.isChecked():
-                include_snapshots = "yes"
-            if self.uiResetMacAddressesCheckBox.isChecked():
-                reset_mac_addresses = "yes"
-            if self.uiKeepComputeIdsCheckBox.isChecked():
-                keep_compute_ids = "yes"
-
-            compression = self.uiCompressionComboBox.currentData()
-            export_worker = ExportProjectWorker(self._project, self._path, include_images, include_snapshots, reset_mac_addresses, keep_compute_ids, compression)
-            progress_dialog = ProgressDialog(export_worker, "Exporting project", "Exporting portable project files...", "Cancel", parent=self, create_thread=False)
-            progress_dialog.show()
-            progress_dialog.exec()
-        super().done(result)

gns3/dialogs/project_welcome_dialog.py

@@ -1,87 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2018 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 copy
-
-from gns3.qt import QtWidgets, QtCore, qpartial
-from gns3.ui.project_welcome_dialog_ui import Ui_ProjectWelcomeDialog
-
-import logging
-log = logging.getLogger(__name__)
-
-
-class ProjectWelcomeDialog(QtWidgets.QDialog, Ui_ProjectWelcomeDialog):
-    """
-    This dialog shows when project is imported and global variables assigned to the project are missing.
-    """
-
-    def __init__(self, parent, project):
-
-        super().__init__(parent)
-        self._project = project
-        self.setupUi(self)
-        self.uiOkButton.clicked.connect(self._okButtonClickedSlot)
-        self.gridLayout.setAlignment(QtCore.Qt.AlignmentFlag.AlignTop)
-        self.label.setOpenExternalLinks(True)
-        self._variables = self._getVariables(project)
-        self._loadReadme()
-        self._addMisingVariablesEdits()
-
-    def _getVariables(self, project):
-        variables = copy.copy(self._project.variables())
-        if variables is None:
-            variables = []
-        return variables
-
-    def _addMisingVariablesEdits(self):
-        #TODO: refactor this to use a QListWidget
-        missing = [v for v in self._variables if v.get("name") and v.get("value", "").strip() == ""]
-        for i, variable in enumerate(missing, start=0):
-            nameLabel = QtWidgets.QLabel()
-            nameLabel.setText(variable.get("name") + ":")
-            self.gridLayout.addWidget(nameLabel, i, 0)
-
-            valueEdit = QtWidgets.QLineEdit()
-            valueEdit.setText(variable.get("value", ""))
-            valueEdit.textChanged.connect(qpartial(self.onValueChange, variable))
-            self.gridLayout.addWidget(valueEdit, i, 1)
-
-    def _loadReadme(self):
-        self._project.get("/files/README.txt", self._loadedReadme)
-
-    def _loadedReadme(self, result, error=False, raw_body=None, context={}, **kwargs):
-        if not error:
-            self.label.setText(raw_body.decode("utf-8"))
-
-    def onValueChange(self, variable, text):
-        variable["value"] = text
-
-    def _okButtonClickedSlot(self):
-        missing = [v for v in self._variables if v.get("name") and v.get("value", "").strip() == ""]
-        if len(missing) > 0:
-            reply = QtWidgets.QMessageBox.warning(self,
-                                                  "Missing values",
-                                                  "Are you sure you want to continue without providing missing values?",
-                                                  QtWidgets.QMessageBox.StandardButton.Yes,
-                                                  QtWidgets.QMessageBox.StandardButton.No)
-            if reply == QtWidgets.QMessageBox.StandardButton.No:
-                return
-
-        self._project.setVariables(self._variables)
-        self._project.update()
-        self.accept()
-

gns3/dialogs/setup_wizard.py

@@ -17,22 +17,19 @@
 
 import sys
 import os
-import shutil
+import psutil
 
-from gns3.qt import QtCore, QtWidgets, QtGui, QtNetwork, qslot
-from gns3.controller import Controller
-from gns3.local_server import LocalServer
-from gns3.utils.interfaces import interfaces
-
-from ..settings import DEFAULT_LOCAL_SERVER_HOST
+from gns3.qt import QtCore, QtWidgets, QtGui
+from gns3.servers import Servers
+from ..gns3_vm import GNS3VM
+from ..dialogs.preferences_dialog import PreferencesDialog
 from ..ui.setup_wizard_ui import Ui_SetupWizard
+from ..utils.progress_dialog import ProgressDialog
+from ..utils.wait_for_vm_worker import WaitForVMWorker
+from ..utils.wait_for_connection_worker import WaitForConnectionWorker
 from ..version import __version__
 
 
-import logging
-log = logging.getLogger(__name__)
-
-
 class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
 
     """
@@ -43,31 +40,18 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
 
         super().__init__(parent)
         self.setupUi(self)
-        self.adjustSize()
 
-        self._gns3_vm_settings = {
-            "enable": True,
-            "headless": False,
-            "when_exit": "stop",
-            "engine": "vmware",
-            "allocate_vcpus_ram": True,
-            "vcpus": 1,
-            "ram": 2048,
-            "vmname": "GNS3 VM",
-            "port": 80
-        }
-
-        self.setWizardStyle(QtWidgets.QWizard.WizardStyle.ModernStyle)
+        self.setWizardStyle(QtWidgets.QWizard.ModernStyle)
         if sys.platform.startswith("darwin"):
             # we want to see the cancel button on OSX
-            self.setOptions(QtWidgets.QWizard.WizardOption.NoDefaultButton)
+            self.setOptions(QtWidgets.QWizard.NoDefaultButton)
 
-        self.uiLocalServerToolButton.clicked.connect(self._localServerBrowserSlot)
-
-        self.uiGNS3VMDownloadLinkUrlLabel.setText("")
+        self._server = Servers.instance().localServer()
+        self.uiGNS3VMDownloadLinkUrlLabel.setText('')
         self.uiRefreshPushButton.clicked.connect(self._refreshVMListSlot)
         self.uiVmwareRadioButton.clicked.connect(self._listVMwareVMsSlot)
         self.uiVirtualBoxRadioButton.clicked.connect(self._listVirtualBoxVMsSlot)
+        self.uiVMwareBannerButton.clicked.connect(self._VMwareBannerButtonClickedSlot)
         settings = parent.settings()
         self.uiShowCheckBox.setChecked(settings["hide_setup_wizard"])
 
@@ -77,44 +61,17 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
         self.uiVmwareRadioButton.setChecked(False)
         self.uiVirtualBoxRadioButton.setChecked(False)
 
-        # Mandatory fields
-        self.uiLocalServerWizardPage.registerField("path*", self.uiLocalServerPathLineEdit)
+        if sys.platform.startswith("darwin"):
+            self.uiVMwareBannerButton.setIcon(QtGui.QIcon(":/images/vmware_fusion_banner.jpg"))
+        else:
+            self.uiVMwareBannerButton.setIcon(QtGui.QIcon(":/images/vmware_workstation_banner.jpg"))
 
-        # load all available addresses
-        for address in QtNetwork.QNetworkInterface.allAddresses():
-            if address.protocol() in [QtNetwork.QAbstractSocket.NetworkLayerProtocol.IPv4Protocol, QtNetwork.QAbstractSocket.NetworkLayerProtocol.IPv6Protocol]:
-                address_string = address.toString()
-                if address_string.startswith("169.254") or address_string.startswith("fe80"):
-                    # ignore link-local addresses, could not use https://doc.qt.io/qt-5/qhostaddress.html#isLinkLocal
-                    # because it was introduced in Qt 5.11
-                    continue
-                self.uiLocalServerHostComboBox.addItem(address_string, address_string)
-
-        self.uiLocalServerHostComboBox.addItem("localhost", "localhost")  # local host
-        self.uiLocalServerHostComboBox.addItem("::", "::")  # all IPv6 addresses
-        self.uiLocalServerHostComboBox.addItem("0.0.0.0", "0.0.0.0")  # all IPv4 addresses
-
-        if sys.platform.startswith("linux"):
-            self.uiLocalRadioButton.setChecked(True)
-            self.uiLocalLabel.setText("Dependencies like Dynamips and Qemu must be manually installed")
-
-        Controller.instance().connected_signal.connect(self._refreshLocalServerStatusSlot)
-        Controller.instance().connection_failed_signal.connect(self._refreshLocalServerStatusSlot)
-
-    def _localServerBrowserSlot(self):
-        """
-        Slot to open a file browser and select a local server.
-        """
-
-        filter = ""
-        if sys.platform.startswith("win"):
-            filter = "Executable (*.exe);;All files (*.*)"
-        server_path = shutil.which("gns3server")
-        path, _ = QtWidgets.QFileDialog.getOpenFileName(self, "Select the local server", server_path, filter)
-        if not path:
-            return
-
-        self.uiLocalServerPathLineEdit.setText(path)
+    def _VMwareBannerButtonClickedSlot(self):
+        if sys.platform.startswith("darwin"):
+            url = "http://send.onenetworkdirect.net/z/616461/CD225091/"
+        else:
+            url = "http://send.onenetworkdirect.net/z/616460/CD225091/"
+        QtGui.QDesktopServices.openUrl(QtCore.QUrl(url))
 
     def _listVMwareVMsSlot(self):
         """
@@ -127,7 +84,7 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
         from gns3.modules import VMware
         settings = VMware.instance().settings()
         if not os.path.exists(settings["vmrun_path"]):
-            QtWidgets.QMessageBox.critical(self, "VMware", "VMware vmrun tool could not be found, VMware or the VIX API (required for VMware player) is probably not installed. You can download it from https://customerconnect.vmware.com/downloads/details?downloadGroup=PLAYER-1400-VIX1170&productId=687. After installation you need to restart GNS3.")
+            QtWidgets.QMessageBox.critical(self, "VMware", "VMware vmrun tool could not be found, VMware or the VIX API (required for VMware player) is probably not installed. You can download it from https://www.vmware.com/support/developer/vix-api/. After installation you need to restart GNS3.")
             return
         self._refreshVMListSlot()
 
@@ -136,6 +93,7 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
         Slot to refresh the VirtualBox VMs list.
         """
 
+        QtWidgets.QMessageBox.warning(self, "GNS3 VM on VirtualBox", "VirtualBox doesn't support nested virtualization, this means running Qemu based VM could be very slow")
         download_url = "https://github.com/GNS3/gns3-gui/releases/download/v{version}/GNS3.VM.VirtualBox.{version}.zip".format(version=__version__)
         self.uiGNS3VMDownloadLinkUrlLabel.setText('If you don\'t have the GNS3 Virtual Machine you can <a href="{download_url}">download it here</a>.<br>And import the VM in the virtualization software and hit refresh.'.format(download_url=download_url))
         self.uiVmwareRadioButton.setChecked(False)
@@ -156,18 +114,11 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
         :returns: current QWidget
         """
 
-        pane = dialog.uiTreeWidget.findItems(name, QtCore.Qt.MatchFlag.MatchFixedString)[0]
+        pane = dialog.uiTreeWidget.findItems(name, QtCore.Qt.MatchFixedString)[0]
         child_pane = pane.child(0)
         dialog.uiTreeWidget.setCurrentItem(child_pane)
         return dialog.uiStackedWidget.currentWidget()
 
-    def _getSettingsCallback(self, result, error=False, **kwargs):
-        if error:
-            if "message" in result:
-                log.error("Error while get gettings: {}".format(result["message"]))
-            return
-        self._gns3_vm_settings = result
-
     def initializePage(self, page_id):
         """
         Initialize Wizard pages.
@@ -176,187 +127,107 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
         """
 
         super().initializePage(page_id)
-        if self.page(page_id) == self.uiServerWizardPage:
-            Controller.instance().setDisplayError(False)
-            Controller.instance().get("/gns3vm", self._getSettingsCallback)
-        elif self.page(page_id) == self.uiVMWizardPage:
-            if self._GNS3VMSettings()["engine"] == "vmware":
-                self.uiVmwareRadioButton.setChecked(True)
-                self._listVMwareVMsSlot()
-            elif self._GNS3VMSettings()["engine"] == "virtualbox":
-                self.uiVirtualBoxRadioButton.setChecked(True)
-                self._listVirtualBoxVMsSlot()
-            self.uiCPUSpinBox.setValue(self._GNS3VMSettings()["vcpus"])
-            self.uiRAMSpinBox.setValue(self._GNS3VMSettings()["ram"])
-
-        elif self.page(page_id) == self.uiLocalServerWizardPage:
-            local_server_settings = LocalServer.instance().localServerSettings()
-            self.uiLocalServerPathLineEdit.setText(local_server_settings["path"])
-            index = self.uiLocalServerHostComboBox.findData(local_server_settings["host"])
-            if index != -1:
-                self.uiLocalServerHostComboBox.setCurrentIndex(index)
-            else:
-                if self.uiVMRadioButton.isChecked():
-                    # Try to bind with the IP address allocated for VMnet1
-                    for interface in interfaces():
-                        if "vmnet1" in interface["name"].lower():
-                            index = self.uiLocalServerHostComboBox.findText(interface["ip_address"])
-                            break
-                else:
-                    index = self.uiLocalServerHostComboBox.findText(DEFAULT_LOCAL_SERVER_HOST)
-
-                if index != -1:
-                    self.uiLocalServerHostComboBox.setCurrentIndex(index)
-
-            self.uiLocalServerPortSpinBox.setValue(local_server_settings["port"])
-
-        elif self.page(page_id) == self.uiRemoteControllerWizardPage:
-            local_server_settings = LocalServer.instance().localServerSettings()
-            if local_server_settings["host"] is None:
-                self.uiRemoteMainServerHostLineEdit.setText(DEFAULT_LOCAL_SERVER_HOST)
-                self.uiRemoteMainServerAuthCheckBox.setChecked(False)
-                self.uiRemoteMainServerUserLineEdit.setText("")
-                self.uiRemoteMainServerPasswordLineEdit.setText("")
-            else:
-                self.uiRemoteMainServerHostLineEdit.setText(local_server_settings["host"])
-                self.uiRemoteMainServerAuthCheckBox.setChecked(local_server_settings["auth"])
-                self.uiRemoteMainServerUserLineEdit.setText(local_server_settings["user"])
-                self.uiRemoteMainServerPasswordLineEdit.setText(local_server_settings["password"])
-            self.uiRemoteMainServerPortSpinBox.setValue(local_server_settings["port"])
-        elif self.page(page_id) == self.uiLocalServerStatusWizardPage:
-            self._refreshLocalServerStatusSlot()
-
-        elif self.page(page_id) == self.uiSummaryWizardPage:
-            self.uiSummaryTreeWidget.clear()
-            if self.uiLocalRadioButton.isChecked():
-                local_server_settings = LocalServer.instance().localServerSettings()
-                self._addSummaryEntry("Server type:", "Local")
-                self._addSummaryEntry("Path:", local_server_settings["path"])
-                self._addSummaryEntry("Host:", local_server_settings["host"])
-                self._addSummaryEntry("Port:", str(local_server_settings["port"]))
-            elif self.uiRemoteControllerRadioButton.isChecked():
-                local_server_settings = LocalServer.instance().localServerSettings()
-                self._addSummaryEntry("Server type:", "Remote")
-                self._addSummaryEntry("Host:", local_server_settings["host"])
-                self._addSummaryEntry("Port:", str(local_server_settings["port"]))
-                self._addSummaryEntry("User:", local_server_settings["user"])
-            else:
-                self._addSummaryEntry("Server type:", "GNS3 Virtual Machine")
-                self._addSummaryEntry("VM engine:", self._GNS3VMSettings()["engine"].capitalize())
-                self._addSummaryEntry("VM name:", self._GNS3VMSettings()["vmname"])
-                self._addSummaryEntry("VM vCPUs:", str(self._GNS3VMSettings()["vcpus"]))
-                self._addSummaryEntry("VM RAM:", str(self._GNS3VMSettings()["ram"]) + " MB")
-
-    @qslot
-    def _refreshLocalServerStatusSlot(self):
-        """
-        Refresh the local server status page
-        """
-
-        self.uiLocalServerTextEdit.clear()
-        if Controller.instance().connected():
-            self.uiLocalServerTextEdit.setText("Connection to the local GNS3 server has been successful!")
-            Controller.instance().get("/gns3vm", self._getSettingsCallback)
-        elif Controller.instance().connecting():
-            self.uiLocalServerTextEdit.setText("Please wait connection to the GNS3 server...")
-        else:
-            local_server_settings = LocalServer.instance().localServerSettings()
-            self.uiLocalServerTextEdit.setText("Connection to local server failed. Please try one of the following:\n\n- Make sure GNS3 is allowed to run by your firewall.\n- Go back and try to change the server host binding and/or the port\n- Check with a browser if you can connect to {protocol}://{host}:{port}.\n- Try to run {path} in a terminal to see if you have an error.".format(protocol=local_server_settings["protocol"], host=local_server_settings["host"], port=local_server_settings["port"], path=local_server_settings["path"]))
-
-    def _GNS3VMSettings(self):
-        return self._gns3_vm_settings
-
-    def _setGNS3VMSettings(self, settings):
-        Controller.instance().put("/gns3vm", self._saveSettingsCallback, settings, timeout=60 * 5)
-
-    def _saveSettingsCallback(self, result, error=False, **kwargs):
-        if error:
-            if "message" in result:
-                QtWidgets.QMessageBox.critical(self, "Save settings", "Error while saving settings: {}".format(result["message"]))
-            return
-
-    def _addSummaryEntry(self, name, value):
-
-        item = QtWidgets.QTreeWidgetItem(self.uiSummaryTreeWidget, [name, value])
-        item.setText(0, name)
-        font = item.font(0)
-        font.setBold(True)
-        item.setFont(0, font)
+        if self.page(page_id) == self.uiVMWizardPage:
+            # limit the number of vCPUs to the number of physical cores (hyper thread CPUs are excluded)
+            # because this is likely to degrade performances.
+            cpu_count = psutil.cpu_count(logical=False)
+            self.uiCPUSpinBox.setValue(cpu_count)
+            # we want to allocate half of the available physical memory
+            ram = int(psutil.virtual_memory().total / (1024 * 1024) / 2)
+            # value must be a multiple of 4 (VMware requirement)
+            ram -= ram % 4
+            self.uiRAMSpinBox.setValue(ram)
 
     def validateCurrentPage(self):
         """
         Validates the settings.
         """
 
-        Controller.instance().setDisplayError(True)
+        gns3_vm = GNS3VM.instance()
+        servers = Servers.instance()
         if self.currentPage() == self.uiVMWizardPage:
             vmname = self.uiVMListComboBox.currentText()
             if vmname:
                 # save the GNS3 VM settings
-                vm_settings = self._GNS3VMSettings()
-                vm_settings["enable"] = True
-                vm_settings["vmname"] = vmname
-
+                vm_settings = {"auto_start": True,
+                               "vmname": vmname,
+                               "vmx_path": self.uiVMListComboBox.currentData()}
                 if self.uiVmwareRadioButton.isChecked():
-                    vm_settings["engine"] = "vmware"
+                    vm_settings["virtualization"] = "VMware"
                 elif self.uiVirtualBoxRadioButton.isChecked():
-                    vm_settings["engine"] = "virtualbox"
+                    vm_settings["virtualization"] = "VirtualBox"
+                gns3_vm.setSettings(vm_settings)
+                servers.save()
 
                 # set the vCPU count and RAM
                 vpcus = self.uiCPUSpinBox.value()
                 ram = self.uiRAMSpinBox.value()
                 if ram < 1024:
-                    QtWidgets.QMessageBox.warning(self, "GNS3 VM memory", "It is recommended to allocate a minimum of 1024 MB of memory to the GNS3 VM")
-                vm_settings["vcpus"] = vpcus
-                vm_settings["ram"] = ram
+                    QtWidgets.QMessageBox.warning(self, "GNS3 VM memory", "It is recommended to allocate a minimum of 1024 MB of RAM to the GNS3 VM")
+                available_ram = int(psutil.virtual_memory().available / (1024 * 1024))
+                if ram > available_ram:
+                    QtWidgets.QMessageBox.warning(self, "GNS3 VM memory", "You have probably allocated too much memory for the GNS3 VM! (available memory is {} MB)".format(available_ram))
+                if gns3_vm.setvCPUandRAM(vpcus, ram) is False:
+                    QtWidgets.QMessageBox.warning(self, "GNS3 VM", "Could not configure vCPUs and RAM amounts for the GNS3 VM")
 
-                self._setGNS3VMSettings(vm_settings)
+                # start the GNS3 VM
+                servers.initVMServer()
+                worker = WaitForVMWorker()
+                progress_dialog = ProgressDialog(worker, "GNS3 VM", "Starting the GNS3 VM...", "Cancel", busy=True, parent=self, delay=5)
+                progress_dialog.show()
+                if progress_dialog.exec_():
+                    previous_local_server_ip = servers.localServer().host()
+                    new_local_server_ip = gns3_vm.adjustLocalServerIP()
+                    self.uiShowCheckBox.setChecked(True)
+                    # restart the local server if necessary
+                    if new_local_server_ip != previous_local_server_ip:
+                        servers.stopLocalServer(wait=True)
+                        if servers.startLocalServer():
+                            worker = WaitForConnectionWorker(new_local_server_ip, servers.localServer().port())
+                            dialog = ProgressDialog(worker, "Local server", "Connecting...", "Cancel", busy=True, parent=self)
+                            dialog.show()
+                            dialog.exec_()
             else:
                 if not self.uiVmwareRadioButton.isChecked() and not self.uiVirtualBoxRadioButton.isChecked():
                     QtWidgets.QMessageBox.warning(self, "GNS3 VM", "Please select VMware or VirtualBox")
                 else:
                     QtWidgets.QMessageBox.warning(self, "GNS3 VM", "Please select a VM. If no VM is listed, check if the GNS3 VM is correctly imported and press refresh.")
                 return False
-        elif self.currentPage() == self.uiLocalServerWizardPage:
-            local_server_settings = LocalServer.instance().localServerSettings()
-            local_server_settings["auto_start"] = True
-            local_server_settings["path"] = self.uiLocalServerPathLineEdit.text().strip()
-            local_server_settings["host"] = self.uiLocalServerHostComboBox.itemData(self.uiLocalServerHostComboBox.currentIndex())
-            local_server_settings["port"] = self.uiLocalServerPortSpinBox.value()
+        elif self.currentPage() == self.uiAddVMsWizardPage:
 
-            if not os.path.isfile(local_server_settings["path"]):
-                QtWidgets.QMessageBox.critical(self, "Local server", "Could not find local server {}".format(local_server_settings["path"]))
-                return False
-            if not os.access(local_server_settings["path"], os.X_OK):
-                QtWidgets.QMessageBox.critical(self, "Local server", "{} is not an executable".format(local_server_settings["path"]))
-                return False
-
-            LocalServer.instance().updateLocalServerSettings(local_server_settings)
-            if not LocalServer.instance().localServerAutoStartIfRequired():
-                return False
-
-        elif self.currentPage() == self.uiRemoteControllerWizardPage:
-            local_server_settings = LocalServer.instance().localServerSettings()
-            local_server_settings["auto_start"] = False
-            local_server_settings["host"] = self.uiRemoteMainServerHostLineEdit.text()
-            local_server_settings["port"] = self.uiRemoteMainServerPortSpinBox.value()
-            local_server_settings["protocol"] = "http"
-            local_server_settings["user"] = self.uiRemoteMainServerUserLineEdit.text()
-            local_server_settings["password"] = self.uiRemoteMainServerPasswordLineEdit.text()
-            local_server_settings["auth"] = self.uiRemoteMainServerAuthCheckBox.isChecked()
-            LocalServer.instance().updateLocalServerSettings(local_server_settings)
-
-        elif self.currentPage() == self.uiSummaryWizardPage:
-            if self.uiLocalRadioButton.isChecked():
+            use_local_server = self.uiLocalRadioButton.isChecked()
+            if use_local_server:
                 # deactivate the GNS3 VM if using the local server
-                vm_settings = self._GNS3VMSettings()
-                vm_settings["enable"] = False
-                self._setGNS3VMSettings(vm_settings)
+                vm_settings = {"auto_start": False}
+                gns3_vm.setSettings(vm_settings)
+                servers.save()
+                self.uiShowCheckBox.setChecked(True)
 
-        elif self.currentPage() == self.uiLocalServerStatusWizardPage:
-            if not Controller.instance().connected():
-                return False
+            from gns3.modules import Dynamips
+            Dynamips.instance().setSettings({"use_local_server": use_local_server})
+            if sys.platform.startswith("linux"):
+                # IOU only works on Linux
+                from gns3.modules import IOU
+                IOU.instance().setSettings({"use_local_server": use_local_server})
+            from gns3.modules import Qemu
+            Qemu.instance().setSettings({"use_local_server": use_local_server})
+            from gns3.modules import VPCS
+            VPCS.instance().setSettings({"use_local_server": use_local_server})
 
+            dialog = PreferencesDialog(self)
+            if self.uiAddIOSRouterCheckBox.isChecked():
+                self._setPreferencesPane(dialog, "Dynamips").uiNewIOSRouterPushButton.clicked.emit(False)
+            if self.uiAddIOUDeviceCheckBox.isChecked():
+                self._setPreferencesPane(dialog, "IOS on UNIX").uiNewIOUDevicePushButton.clicked.emit(False)
+            if self.uiAddQemuVMcheckBox.isChecked():
+                self._setPreferencesPane(dialog, "QEMU").uiNewQemuVMPushButton.clicked.emit(False)
+            if self.uiAddVirtualBoxVMcheckBox.isChecked():
+                self._setPreferencesPane(dialog, "VirtualBox").uiNewVirtualBoxVMPushButton.clicked.emit(False)
+            if self.uiAddVMwareVMcheckBox.isChecked():
+                self._setPreferencesPane(dialog, "VMware").uiNewVMwareVMPushButton.clicked.emit(False)
+            if self.uiAddDockerVMCheckBox.isChecked():
+                self._setPreferencesPane(dialog, "Docker").uiNewDockerVMPushButton.clicked.emit(False)
+            dialog.exec_()
         return True
 
     def _refreshVMListSlot(self):
@@ -364,10 +235,11 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
         Refresh the list of VM available in VMware or VirtualBox.
         """
 
+        server = Servers.instance().localServer()
         if self.uiVmwareRadioButton.isChecked():
-            Controller.instance().get("/gns3vm/engines/vmware/vms", self._getVMsFromServerCallback, progressText="Retrieving VMware VM list from server...")
+            server.get("/vmware/vms", self._getVMsFromServerCallback)
         elif self.uiVirtualBoxRadioButton.isChecked():
-            Controller.instance().get("/gns3vm/engines/virtualbox/vms", self._getVMsFromServerCallback, progressText="Retrieving VirtualBox VM list from server...")
+            server.get("/virtualbox/vms", self._getVMsFromServerCallback)
 
     def _getVMsFromServerCallback(self, result, error=False, **kwargs):
         """
@@ -383,9 +255,9 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
         else:
             self.uiVMListComboBox.clear()
             for vm in result:
-                self.uiVMListComboBox.addItem(vm["vmname"])
-
-            index = self.uiVMListComboBox.findText(self._GNS3VMSettings()["vmname"])
+                self.uiVMListComboBox.addItem(vm["vmname"], vm.get("vmx_path", ""))
+            gns3_vm = Servers.instance().vmSettings()
+            index = self.uiVMListComboBox.findText(gns3_vm["vmname"])
             if index != -1:
                 self.uiVMListComboBox.setCurrentIndex(index)
             else:
@@ -402,14 +274,8 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
         :param result: ignored
         """
 
-        Controller.instance().setDisplayError(True)
         settings = self.parentWidget().settings()
-        if result:
-            settings["hide_setup_wizard"] = True
-        else:
-            local_server_settings = LocalServer.instance().localServerSettings()
-            LocalServer.instance().updateLocalServerSettings(local_server_settings)
-            settings["hide_setup_wizard"] = not self.uiShowCheckBox.isChecked()
+        settings["hide_setup_wizard"] = self.uiShowCheckBox.isChecked()
         self.parentWidget().setSettings(settings)
         super().done(result)
 
@@ -419,21 +285,7 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
         """
 
         current_id = self.currentId()
-        if self.page(current_id) == self.uiLocalServerStatusWizardPage and not self.uiVMRadioButton.isChecked():
-            return self._pageId(self.uiSummaryWizardPage)
-
-        if self.page(current_id) == self.uiServerWizardPage and self.uiRemoteControllerRadioButton.isChecked():
-            return self._pageId(self.uiRemoteControllerWizardPage)
-
-        if self.page(current_id) == self.uiVMWizardPage:
-            return self._pageId(self.uiSummaryWizardPage)
+        if self.page(current_id) == self.uiServerWizardPage and not self.uiVMRadioButton.isChecked():
+            # skip the GNS3 VM page if using the local server.
+            return self.uiServerWizardPage.nextId() + 1
         return QtWidgets.QWizard.nextId(self)
-
-    def _pageId(self, page):
-        """
-        Return id of the page
-        """
-        for id in self.pageIds():
-            if self.page(id) == page:
-                return id
-        raise KeyError

gns3/dialogs/snapshots_dialog.py

@@ -19,14 +19,17 @@
 Dialog to manage the snapshots.
 """
 
+import shutil
+import re
+import time
+import os
+
 from ..qt import QtCore, QtWidgets
+from ..utils.progress_dialog import ProgressDialog
+from ..utils.process_files_worker import ProcessFilesWorker
 from ..ui.snapshots_dialog_ui import Ui_SnapshotsDialog
-from ..controller import Controller
-
-from datetime import datetime
-
-import logging
-log = logging.getLogger(__name__)
+from ..topology import Topology
+from ..node import Node
 
 
 class SnapshotsDialog(QtWidgets.QDialog, Ui_SnapshotsDialog):
@@ -37,38 +40,46 @@ class SnapshotsDialog(QtWidgets.QDialog, Ui_SnapshotsDialog):
     :param parent: parent widget
     """
 
-    def __init__(self, parent, project):
+    def __init__(self, parent, project_path, project_files_dir):
 
         super().__init__(parent)
         self.setupUi(self)
 
-        self._project = project
+        self._project_path = project_path
+        self._project_files_dir = os.path.join(project_files_dir, "project-files")
 
         self.uiCreatePushButton.clicked.connect(self._createSnapshotSlot)
         self.uiDeletePushButton.clicked.connect(self._deleteSnapshotSlot)
         self.uiRestorePushButton.clicked.connect(self._restoreSnapshotSlot)
         self.uiSnapshotsList.itemDoubleClicked.connect(self._snapshotDoubleClickedSlot)
-        self._listSnapshots()
+        self._listSnaphosts()
 
-    def _listSnapshots(self):
+    def _listSnaphosts(self):
         """
         Lists all available snapshots.
         """
 
         self.uiSnapshotsList.clear()
-        if self._project:
-            Controller.instance().get("/projects/{}/snapshots".format(self._project.id()), self._listSnapshotsCallback)
-
-    def _listSnapshotsCallback(self, result, error=False, server=None, context={}, **kwargs):
-        if error:
-            if result:
-                log.error(result["message"])
+        snapshot_dir = os.path.join(self._project_files_dir, "snapshots")
+        if not os.path.isdir(snapshot_dir):
             return
 
-        for snapshot in result:
+        snapshots = []
+        for snapshot in os.listdir(snapshot_dir):
+            match = re.search(r"^(.*)_([0-9]+)_([0-9]+)", snapshot)
+            if match:
+                snapshot_name = match.group(1)
+                snapshot_date = match.group(2)[:2] + '/' + match.group(2)[2:4] + '/' + match.group(2)[4:]
+                snapshot_time = match.group(3)[:2] + ':' + match.group(3)[2:4] + ':' + match.group(3)[4:]
+                snapshots.append((snapshot_name, snapshot_date, snapshot_time))
+
+        # Sort by date
+        snapshots = sorted(snapshots, key=(lambda v: v[1] + v[2]))
+        for snapshot_name, snapshot_date, snapshot_time in snapshots:
             item = QtWidgets.QListWidgetItem(self.uiSnapshotsList)
-            item.setText("{} on {}".format(snapshot["name"], datetime.fromtimestamp(snapshot["created_at"]).strftime("%Y-%m-%d at %H:%M:%S")))
-            item.setData(QtCore.Qt.ItemDataRole.UserRole, snapshot["snapshot_id"])
+            item.setText("{} on {} at {}".format(snapshot_name, snapshot_date, snapshot_time))
+            item.setData(QtCore.Qt.UserRole, os.path.join(snapshot_dir, snapshot))
+
 
         if self.uiSnapshotsList.count():
             self.uiSnapshotsList.setCurrentRow(0)
@@ -83,22 +94,17 @@ class SnapshotsDialog(QtWidgets.QDialog, Ui_SnapshotsDialog):
         Slot to create a snapshot.
         """
 
-        snapshot_name, ok = QtWidgets.QInputDialog.getText(self, "Snapshot", "Snapshot name:", QtWidgets.QLineEdit.EchoMode.Normal, "Unnamed")
-        if ok and snapshot_name and self._project:
-            Controller.instance().post("/projects/{}/snapshots".format(self._project.id()),
-                                       self._createSnapshotsCallback,
-                                       {"name": snapshot_name},
-                                       progressText="Creation of snapshot '{}' in progress...".format(snapshot_name),
-                                       timeout=None)
-
-    def _createSnapshotsCallback(self, result, error=False, server=None, context={}, **kwargs):
-        if error:
-            if result:
-                log.error(result["message"])
-            else:
-                log.error("Cannot create snapshot of project")
-            return
-        self._listSnapshots()
+        snapshot_name, ok = QtWidgets.QInputDialog.getText(self, "Snapshot", "Snapshot name:", QtWidgets.QLineEdit.Normal, "Unnamed")
+        if ok and snapshot_name:
+            from ..main_window import MainWindow
+            MainWindow.instance().saveProject(self._project_path)
+            snapshot_name = "{name}_{date}".format(name=snapshot_name, date=time.strftime("%d%m%y_%H%M%S"))
+            snapshot_dir = os.path.join(self._project_files_dir, "snapshots", snapshot_name)
+            worker = ProcessFilesWorker(os.path.dirname(self._project_path), snapshot_dir, skip_dirs=["snapshots"])
+            progress_dialog = ProgressDialog(worker, "Creating snapshot", "Copying project files...", "Cancel", parent=self)
+            progress_dialog.show()
+            progress_dialog.exec_()
+            self._listSnaphosts()
 
     def _deleteSnapshotSlot(self):
         """
@@ -107,16 +113,9 @@ class SnapshotsDialog(QtWidgets.QDialog, Ui_SnapshotsDialog):
 
         item = self.uiSnapshotsList.currentItem()
         if item:
-            snapshot_id = item.data(QtCore.Qt.ItemDataRole.UserRole)
-            Controller.instance().delete("/projects/{}/snapshots/{}".format(self._project.id(), snapshot_id), self._deleteSnapshotsCallback)
-
-    def _deleteSnapshotsCallback(self, result, error=False, server=None, context={}, **kwargs):
-
-        if error:
-            if result:
-                log.error(result["message"])
-            return
-        self._listSnapshots()
+            snapshot_path = item.data(QtCore.Qt.UserRole)
+            shutil.rmtree(snapshot_path, ignore_errors=True)
+            self._listSnaphosts()
 
     def _restoreSnapshotSlot(self):
         """
@@ -125,29 +124,63 @@ class SnapshotsDialog(QtWidgets.QDialog, Ui_SnapshotsDialog):
 
         item = self.uiSnapshotsList.currentItem()
         if item:
-            snapshot_id = item.data(QtCore.Qt.ItemDataRole.UserRole)
-            self._restoreSnapshot(snapshot_id)
+            snapshot_path = item.data(QtCore.Qt.UserRole)
+            self._restoreSnapshot(snapshot_path)
 
-    def _restoreSnapshot(self, snapshot_id):
+    def _restoreSnapshot(self, snapshot_path):
         """
         Restores a snapshot.
 
-        :param snapshot_id: id of the snapshot
+        :param snapshot_path: path to the snapshot
         """
 
-        reply = QtWidgets.QMessageBox.question(self, "Snapshots", "This will discard any changes made to your project since the snapshot was taken, would you like to proceed?", QtWidgets.QMessageBox.StandardButton.Ok, QtWidgets.QMessageBox.StandardButton.Cancel)
-        if reply == QtWidgets.QMessageBox.StandardButton.Cancel:
+        match = re.search(r"^(.*)_([0-9]+)_([0-9]+)", os.path.basename(snapshot_path))
+        if match:
+            snapshot_name = match.group(1)
+        else:
+            snapshot_name = "Unknown"
+        reply = QtWidgets.QMessageBox.question(self, "Snapshots", "This will discard any changes made to your project since the snapshot \"{}\" was taken?".format(snapshot_name),
+                                               QtWidgets.QMessageBox.Ok, QtWidgets.QMessageBox.Cancel)
+        if reply == QtWidgets.QMessageBox.Cancel:
             return
 
-        Controller.instance().post("/projects/{}/snapshots/{}/restore".format(self._project.id(), snapshot_id),
-                                   self._restoreSnapshotsCallback, progressText="Restoring snapshot...", timeout=None)
+        # stop all the nodes
+        topology = Topology.instance()
+        for node in topology.nodes():
+            if hasattr(node, "start") and node.status() == Node.started:
+                node.stop()
 
-    def _restoreSnapshotsCallback(self, result, error=False, server=None, context={}, **kwargs):
+        project_name, _ = os.path.splitext(os.path.basename(self._project_path))
+        legacy_project_files_dir = os.path.join(snapshot_path, "{}-files".format(project_name))
+        if os.path.exists(legacy_project_files_dir):
+            # support for pre 1.3 snapshots
+            for root, dirs, _ in os.walk(self._project_files_dir):
+                dirs[:] = [d for d in dirs if d not in "snapshots"]
+                for project_subdir in dirs:
+                    project_subdir_path = os.path.join(root, project_subdir)
+                    shutil.rmtree(project_subdir_path, ignore_errors=True)
 
-        if error:
-            if result:
-                log.error(result["message"])
-            return
+            dirs = os.listdir(legacy_project_files_dir)
+            for snapshot_subdir in dirs:
+                snapshot_subdir_path = os.path.join(legacy_project_files_dir, snapshot_subdir)
+                worker = ProcessFilesWorker(snapshot_subdir_path, os.path.join(self._project_files_dir, snapshot_subdir))
+                progress_dialog = ProgressDialog(worker, "Restoring snapshot", "Copying project files...", "Cancel", parent=self)
+                progress_dialog.show()
+                progress_dialog.exec_()
+
+            try:
+                os.remove(self._project_path)
+                shutil.copy(os.path.join(snapshot_path, os.path.basename(self._project_path)), self._project_path)
+            except OSError as e:
+                QtWidgets.QMessageBox.critical(self, "Restore snapshot", "Cannot restore snapshot: {}".format(e))
+        else:
+            worker = ProcessFilesWorker(snapshot_path, os.path.dirname(self._project_path), skip_dirs=["snapshots"])
+            progress_dialog = ProgressDialog(worker, "Restoring snapshot", "Copying project files...", "Cancel", parent=self)
+            progress_dialog.show()
+            progress_dialog.exec_()
+
+        from ..main_window import MainWindow
+        MainWindow.instance().loadSnapshot(self._project_path)
         self.accept()
 
     def _snapshotDoubleClickedSlot(self, item):
@@ -155,5 +188,5 @@ class SnapshotsDialog(QtWidgets.QDialog, Ui_SnapshotsDialog):
         Slot to restore a snapshot when it is double clicked.
         """
 
-        snapshot_id = item.data(QtCore.Qt.ItemDataRole.UserRole)
-        self._restoreSnapshot(snapshot_id)
+        snapshot_path = item.data(QtCore.Qt.UserRole)
+        self._restoreSnapshot(snapshot_path)

gns3/dialogs/style_editor_dialog.py

@@ -21,8 +21,6 @@ Style editor to edit Shape items.
 
 from ..qt import QtCore, QtWidgets, QtGui
 from ..ui.style_editor_dialog_ui import Ui_StyleEditorDialog
-from ..items.shape_item import ShapeItem
-from ..items.rectangle_item import RectangleItem
 
 
 class StyleEditorDialog(QtWidgets.QDialog, Ui_StyleEditorDialog):
@@ -42,56 +40,31 @@ class StyleEditorDialog(QtWidgets.QDialog, Ui_StyleEditorDialog):
         self._items = items
         self.uiColorPushButton.clicked.connect(self._setColorSlot)
         self.uiBorderColorPushButton.clicked.connect(self._setBorderColorSlot)
-        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Apply).clicked.connect(self._applyPreferencesSlot)
+        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.Apply).clicked.connect(self._applyPreferencesSlot)
 
-        self.uiBorderStyleComboBox.addItem("Solid", QtCore.Qt.PenStyle.SolidLine)
-        self.uiBorderStyleComboBox.addItem("Dash", QtCore.Qt.PenStyle.DashLine)
-        self.uiBorderStyleComboBox.addItem("Dot", QtCore.Qt.PenStyle.DotLine)
-        self.uiBorderStyleComboBox.addItem("Dash Dot", QtCore.Qt.PenStyle.DashDotLine)
-        self.uiBorderStyleComboBox.addItem("Dash Dot Dot", QtCore.Qt.PenStyle.DashDotDotLine)
-        self.uiBorderStyleComboBox.addItem("No border", QtCore.Qt.PenStyle.NoPen)
+        self.uiBorderStyleComboBox.addItem("Solid", QtCore.Qt.SolidLine)
+        self.uiBorderStyleComboBox.addItem("Dash", QtCore.Qt.DashLine)
+        self.uiBorderStyleComboBox.addItem("Dot", QtCore.Qt.DotLine)
+        self.uiBorderStyleComboBox.addItem("Dash Dot", QtCore.Qt.DashDotLine)
+        self.uiBorderStyleComboBox.addItem("Dash Dot Dot", QtCore.Qt.DashDotDotLine)
+        self.uiBorderStyleComboBox.addItem("No border", QtCore.Qt.NoPen)
 
         # use the first item in the list as the model
         first_item = items[0]
         pen = first_item.pen()
-        if hasattr(first_item, "brush"):  # Line don't have brush
-            brush = first_item.brush()
-            self._color = brush.color()
-            self.uiColorPushButton.setStyleSheet("background-color: rgba({}, {}, {}, {});".format(self._color.red(),
-                                                                                                  self._color.green(),
-                                                                                                  self._color.blue(),
-                                                                                                  self._color.alpha()))
-        else:
-            self.uiColorLabel.hide()
-            self.uiColorPushButton.hide()
-            self._color = None
-
+        brush = first_item.brush()
+        self._color = brush.color()
+        self.uiColorPushButton.setStyleSheet("background-color: rgba({}, {}, {}, {});".format(self._color.red(),
+                                                                                              self._color.green(),
+                                                                                              self._color.blue(),
+                                                                                              self._color.alpha()))
         self._border_color = pen.color()
         self.uiBorderColorPushButton.setStyleSheet("background-color: rgba({}, {}, {}, {});".format(self._border_color.red(),
                                                                                                     self._border_color.green(),
                                                                                                     self._border_color.blue(),
                                                                                                     self._border_color.alpha()))
-        if isinstance(first_item, RectangleItem):
-            # use the horizontal corner radius first and then the vertical one if it's not set
-            # maybe we allow configuring them separately in the future
-            corner_radius = first_item.horizontalCornerRadius()
-            if not corner_radius:
-                corner_radius = first_item.verticalCornerRadius()
-            self.uiCornerRadiusSpinBox.setValue(corner_radius)
-        else:
-            self.uiCornerRadiusLabel.hide()
-            self.uiCornerRadiusSpinBox.hide()
-        self.uiRotationSpinBox.setValue(int(first_item.rotation()))
+        self.uiRotationSpinBox.setValue(first_item.rotation())
         self.uiBorderWidthSpinBox.setValue(pen.width())
-        if isinstance(first_item, ShapeItem):
-            rect = first_item.rect()
-            self.uiWidthSpinBox.setValue(int(rect.width()))
-            self.uiHeightSpinBox.setValue(int(rect.height()))
-        else:
-            self.uiWidthSpinBox.hide()
-            self.uiWidthLabel.hide()
-            self.uiHeightSpinBox.hide()
-            self.uiHeightLabel.hide()
         index = self.uiBorderStyleComboBox.findData(pen.style())
         if index != -1:
             self.uiBorderStyleComboBox.setCurrentIndex(index)
@@ -101,7 +74,7 @@ class StyleEditorDialog(QtWidgets.QDialog, Ui_StyleEditorDialog):
         Slot to select the filling color.
         """
 
-        color = QtWidgets.QColorDialog.getColor(self._color, self, "Select Color", QtWidgets.QColorDialog.ColorDialogOption.ShowAlphaChannel)
+        color = QtWidgets.QColorDialog.getColor(self._color, self, "Select Color", QtWidgets.QColorDialog.ShowAlphaChannel)
         if color.isValid():
             self._color = color
             self.uiColorPushButton.setStyleSheet("background-color: rgba({}, {}, {}, {});".format(self._color.red(),
@@ -114,7 +87,7 @@ class StyleEditorDialog(QtWidgets.QDialog, Ui_StyleEditorDialog):
         Slot to select the border color.
         """
 
-        color = QtWidgets.QColorDialog.getColor(self._border_color, self, "Select Color", QtWidgets.QColorDialog.ColorDialogOption.ShowAlphaChannel)
+        color = QtWidgets.QColorDialog.getColor(self._border_color, self, "Select Color", QtWidgets.QColorDialog.ShowAlphaChannel)
         if color.isValid():
             self._border_color = color
             self.uiBorderColorPushButton.setStyleSheet("background-color: rgba({}, {}, {}, {});".format(self._border_color.red(),
@@ -128,26 +101,12 @@ class StyleEditorDialog(QtWidgets.QDialog, Ui_StyleEditorDialog):
         """
 
         border_style = QtCore.Qt.PenStyle(self.uiBorderStyleComboBox.itemData(self.uiBorderStyleComboBox.currentIndex()))
-        pen = QtGui.QPen(self._border_color, self.uiBorderWidthSpinBox.value(), border_style, QtCore.Qt.PenCapStyle.RoundCap, QtCore.Qt.PenJoinStyle.RoundJoin)
-        if self._color:
-            brush = QtGui.QBrush(self._color)
-        else:
-            brush = None
+        pen = QtGui.QPen(self._border_color, self.uiBorderWidthSpinBox.value(), border_style, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin)
+        brush = QtGui.QBrush(self._color)
 
         for item in self._items:
             item.setPen(pen)
-            # on multi-selection it's possible to select many type of items
-            # but brush can be applied only on ShapeItem,
-            if brush and isinstance(item, ShapeItem):
-                item.setBrush(brush)
-            if isinstance(item, RectangleItem):
-                corner_radius = self.uiCornerRadiusSpinBox.value()
-                # use the corner radius for both horizontal (rx) and vertical (ry)
-                # maybe we support setting them separately in the future
-                item.setHorizontalCornerRadius(corner_radius)
-                item.setVerticalCornerRadius(corner_radius)
-            if isinstance(item, ShapeItem):
-                item.setWidthAndHeight(self.uiWidthSpinBox.value(), self.uiHeightSpinBox.value())
+            item.setBrush(brush)
             item.setRotation(self.uiRotationSpinBox.value())
 
     def done(self, result):

gns3/dialogs/style_editor_dialog_link.py

@@ -1,128 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2019 Pekka Helenius
-# Copyright (C) 2014 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/>.
-
-"""
-Style editor to edit Link items.
-"""
-
-from ..qt import QtCore, QtWidgets, QtGui
-from ..ui.style_editor_dialog_ui import Ui_StyleEditorDialog
-
-
-class StyleEditorDialogLink(QtWidgets.QDialog, Ui_StyleEditorDialog):
-
-    """
-    Style editor dialog.
-
-    :param parent: parent widget
-    :param link: selected link
-    """
-
-    def __init__(self, link, parent):
-
-        super().__init__(parent)
-        self.setupUi(self)
-
-        self._link = link
-        self._link_style = {}
-
-        self.uiBorderColorLabel.setText("Link color")
-        self.uiBorderWidthLabel.setText("Link width")
-        self.uiBorderStyleLabel.setText("Link style")
-
-        self.uiBorderColorPushButton.clicked.connect(self._setBorderColorSlot)
-        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Apply).clicked.connect(self._applyPreferencesSlot)
-
-        self.uiBorderStyleComboBox.addItem("Solid", QtCore.Qt.PenStyle.SolidLine)
-        self.uiBorderStyleComboBox.addItem("Dash", QtCore.Qt.PenStyle.DashLine)
-        self.uiBorderStyleComboBox.addItem("Dot", QtCore.Qt.PenStyle.DotLine)
-        self.uiBorderStyleComboBox.addItem("Dash Dot", QtCore.Qt.PenStyle.DashDotLine)
-        self.uiBorderStyleComboBox.addItem("Dash Dot Dot", QtCore.Qt.PenStyle.DashDotDotLine)
-        self.uiBorderStyleComboBox.addItem("Invisible", QtCore.Qt.PenStyle.NoPen)
-
-        self.uiColorLabel.hide()
-        self.uiColorPushButton.hide()
-        self._color = None
-
-        self.uiCornerRadiusLabel.hide()
-        self.uiCornerRadiusSpinBox.hide()
-        self.uiRotationLabel.hide()
-        self.uiRotationSpinBox.hide()
-
-        link.setHovered(False)  # make sure we use the right style
-        pen = link.pen()
-        link.setHovered(True)
-
-        self._border_color = pen.color()
-        self.uiBorderColorPushButton.setStyleSheet("background-color: rgba({}, {}, {}, {});".format(
-            self._border_color.red(),
-            self._border_color.green(),
-            self._border_color.blue(),
-            self._border_color.alpha())
-        )
-
-        self.uiBorderWidthSpinBox.setValue(pen.width())
-        index = self.uiBorderStyleComboBox.findData(pen.style())
-        if index != -1:
-            self.uiBorderStyleComboBox.setCurrentIndex(index)
-
-        self.adjustSize()
-
-    def _setBorderColorSlot(self):
-        """
-        Slot to select the border color.
-        """
-
-        color = QtWidgets.QColorDialog.getColor(self._border_color, self, "Select Color", QtWidgets.QColorDialog.ColorDialogOption.ShowAlphaChannel)
-        if color.isValid():
-            self._border_color = color
-            self.uiBorderColorPushButton.setStyleSheet("background-color: rgba({}, {}, {}, {});".format(self._border_color.red(),
-                                                                                                        self._border_color.green(),
-                                                                                                        self._border_color.blue(),
-                                                                                                        self._border_color.alpha()))
-
-    def _applyPreferencesSlot(self):
-        """
-        Applies the new style settings.
-        """
-
-        border_style = QtCore.Qt.PenStyle(self.uiBorderStyleComboBox.itemData(self.uiBorderStyleComboBox.currentIndex()))
-        pen = QtGui.QPen(self._border_color, self.uiBorderWidthSpinBox.value(), border_style, QtCore.Qt.PenCapStyle.RoundCap, QtCore.Qt.PenJoinStyle.RoundJoin)
-
-        self._link.setPen(pen)
-
-        new_link_style = {
-            "color": self._border_color.name(),
-            "width": self.uiBorderWidthSpinBox.value(),
-            "type": border_style.value,
-        }
-
-        # Store values
-        self._link.setLinkStyle(new_link_style)
-        self._link.setHovered(False)  # allow to see the new style
-
-    def done(self, result):
-        """
-        Called when the dialog is closed.
-
-        :param result: boolean (accepted or rejected)
-        """
-
-        if result:
-            self._applyPreferencesSlot()
-        super().done(result)

gns3/dialogs/symbol_selection_dialog.py

@@ -20,14 +20,11 @@ Dialog to change node symbols.
 """
 
 import os
-import pathlib
 
-from ..qt import QtCore, QtGui, QtWidgets, qpartial, sip_is_deleted
+from ..qt import QtCore, QtGui, QtWidgets
 from ..qt.qimage_svg_renderer import QImageSvgRenderer
 from ..ui.symbol_selection_dialog_ui import Ui_SymbolSelectionDialog
-from ..controller import Controller
-from ..symbol import Symbol
-
+from ..servers import Servers
 
 import logging
 log = logging.getLogger(__name__)
@@ -42,78 +39,64 @@ class SymbolSelectionDialog(QtWidgets.QDialog, Ui_SymbolSelectionDialog):
     :param items: list of items
     """
 
-    _symbols_dir = None
-
     def __init__(self, parent, items=None, symbol=None):
 
         super().__init__(parent)
         self.setupUi(self)
 
         self._items = items
-        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Apply).clicked.connect(self._applyPreferencesSlot)
+        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.Apply).clicked.connect(self._applyPreferencesSlot)
         self.uiSymbolToolButton.clicked.connect(self._symbolBrowserSlot)
         self.uiCustomSymbolRadioButton.toggled.connect(self._customSymbolToggledSlot)
         self.uiBuiltInSymbolRadioButton.toggled.connect(self._builtInSymbolToggledSlot)
         self.uiSearchLineEdit.textChanged.connect(self._searchTextChangedSlot)
-        if not SymbolSelectionDialog._symbols_dir:
-            SymbolSelectionDialog._symbols_dir = QtCore.QStandardPaths.writableLocation(QtCore.QStandardPaths.StandardLocation.PicturesLocation)
+        self.uiBuiltinSymbolOnlyCheckBox.toggled.connect(self._builtinSymbolOnlyToggledSlot)
+        self._symbols_dir = QtCore.QStandardPaths.writableLocation(QtCore.QStandardPaths.PicturesLocation)
+        self._symbols_path = Servers.instance().localServerSettings()["symbols_path"]
 
         if not self._items:
-            self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Apply).hide()
+            self.uiButtonBox.button(QtWidgets.QDialogButtonBox.Apply).hide()
 
         self.uiBuiltInSymbolRadioButton.setChecked(True)
-        self.uiSymbolTreeWidget.setFocus()
-        self.uiSymbolTreeWidget.setIconSize(QtCore.QSize(64, 64))
+        self.uiSymbolListWidget.setFocus()
+        self.uiSymbolListWidget.setIconSize(QtCore.QSize(64, 64))
+        symbol_resources = QtCore.QResource(":/symbols")
         self._symbol_items = []
-        self._parents = {}
+        symbols = symbol_resources.children()
 
-        Controller.instance().clearStaticCache()  # TODO: use etag to know when to refresh the cache
-        Controller.instance().get("/symbols", self._listSymbolsCallback)
+        try:
+            for file in os.listdir(self._symbols_path):
+                symbols.append(file)
+        except OSError:
+            pass
 
-    def _listSymbolsCallback(self, result, error=False, **kwargs):
-        if error:
-            log.error("Error while listing symbols: {}".format(result["message"]))
-            return
+        symbols.sort()
+        for symbol in symbols:
+            if symbol.endswith(".svg") or symbol.endswith(".png"):
+                name = os.path.splitext(symbol)[0]
+                item = QtWidgets.QListWidgetItem(self.uiSymbolListWidget)
+                self._symbol_items.append(item)
+                item.setText(name)
 
-        self._symbol_items = []
-        for symbol in result:
-            symbol = Symbol(**symbol)
-            theme = symbol.theme()
-            if theme not in self._parents:
-                parent = QtWidgets.QTreeWidgetItem(self.uiSymbolTreeWidget)
-                parent.setText(0, theme)
-                font = parent.font(0)
-                font.setBold(True)
-                parent.setFont(0, font)
-                parent.setFlags(parent.flags() & ~QtCore.Qt.ItemFlag.ItemIsSelectable)
-                self._parents[theme] = parent
-            else:
-                parent = self._parents[theme]
-
-            name = os.path.splitext(symbol.filename())[0]
-            item = QtWidgets.QTreeWidgetItem(parent)
-            item.setData(0, QtCore.Qt.ItemDataRole.UserRole, symbol)
-            item.setToolTip(0, symbol.id())
-            self._symbol_items.append(item)
-            item.setText(0, name)
-
-            def render(item, path):
-                if sip_is_deleted(item):
-                    return
-                svg_renderer = QImageSvgRenderer(path)
-                image = QtGui.QImage(64, 64, QtGui.QImage.Format.Format_ARGB32)
+                image = QtGui.QImage(64, 64, QtGui.QImage.Format_ARGB32)
                 # Set the ARGB to 0 to prevent rendering artifacts
                 image.fill(0x00000000)
+
+                if os.path.exists(os.path.join(self._symbols_path, symbol)):
+                    svg_renderer = QImageSvgRenderer(os.path.join(self._symbols_path, symbol))
+                else:
+                    resource_path = ":/symbols/" + symbol
+                    svg_renderer = QImageSvgRenderer(resource_path)
                 svg_renderer.render(QtGui.QPainter(image))
+
                 icon = QtGui.QIcon(QtGui.QPixmap.fromImage(image))
-                item.setIcon(0, icon)
+                item.setIcon(icon)
 
-            Controller.instance().getStatic(symbol.url(), qpartial(render, item))
-
-        for parent in self._parents.values():
-            parent.sortChildren(0, QtCore.Qt.SortOrder.AscendingOrder)
         self.adjustSize()
 
+    def _builtinSymbolOnlyToggledSlot(self, checked):
+        self._filter()
+
     def _searchTextChangedSlot(self, text):
         self._filter()
 
@@ -123,13 +106,13 @@ class SymbolSelectionDialog(QtWidgets.QDialog, Ui_SymbolSelectionDialog):
         """
         text = self.uiSearchLineEdit.text()
         for item in self._symbol_items:
-            # if not item.data(0, QtCore.Qt.ItemDataRole.UserRole).builtin():
-            #     item.setHidden(True)
-            # else:
-            if not text.strip() or text.strip().lower() in item.text(0).lower():
-                item.setHidden(False)
-            else:
+            if self.uiBuiltinSymbolOnlyCheckBox.isChecked() and not QtCore.QResource(":/symbols/{}.svg".format(item.text())).isValid():
                 item.setHidden(True)
+            else:
+                if len(text.strip()) == 0 or text.strip().lower() in item.text().lower():
+                    item.setHidden(False)
+                else:
+                    item.setHidden(True)
 
     def _customSymbolToggledSlot(self, checked):
         """
@@ -165,38 +148,46 @@ class SymbolSelectionDialog(QtWidgets.QDialog, Ui_SymbolSelectionDialog):
         """
 
         symbol_path = self.getSymbol()
-        if not symbol_path:
-            return False
-        for item in self._items:
-            item.setSymbol(symbol_path)
+
+        pixmap = QtGui.QPixmap(symbol_path)
+        if not pixmap.isNull():
+            for item in self._items:
+                renderer = QImageSvgRenderer(symbol_path)
+                renderer.setObjectName(symbol_path)
+                if renderer.isValid():
+                    item.setSharedRenderer(renderer)
+                else:
+                    QtWidgets.QMessageBox.critical(self, "Custom pixmap symbol", "Invalid image")
+                    return False
+
         return True
 
     def getSymbol(self):
 
-        if self.uiSymbolTreeWidget.isEnabled():
-            current = self.uiSymbolTreeWidget.currentItem()
-            if current and current.parent():
-                return current.data(0, QtCore.Qt.ItemDataRole.UserRole).id()
+        if self.uiSymbolListWidget.isEnabled():
+            current = self.uiSymbolListWidget.currentItem()
+            if current:
+                name = current.text()
+                if QtCore.QResource(":/symbols/{}.svg".format(name)).isValid():
+                    return ":/symbols/{}.svg".format(name)
+                else:
+                    symbol_path = os.path.join(self._symbols_path, "{}.svg".format(name))
+                    if not os.path.exists(symbol_path):
+                        symbol_path = os.path.join(self._symbols_path, "{}.png".format(name))
+                    return symbol_path
         else:
-            return os.path.basename(self.uiSymbolLineEdit.text())
+            return self.uiSymbolLineEdit.text()
         return None
 
     def _symbolBrowserSlot(self):
 
         # supported image file formats
-        file_formats = "Image files (*.svg *.bmp *.jpeg *.jpg *.pbm *.pgm *.png *.ppm *.xbm *.xpm *.gif);;All files (*)"
-        path, _ = QtWidgets.QFileDialog.getOpenFileName(self, "Image", SymbolSelectionDialog._symbols_dir, file_formats)
+        file_formats = "Image files (*.svg *.bmp *.jpeg *.jpg *.pbm *.pgm *.png *.ppm *.xbm *.xpm *.gif);;All files (*.*)"
+        path, _ = QtWidgets.QFileDialog.getOpenFileName(self, "Image", self._symbols_dir, file_formats)
         if not path:
             return
-        SymbolSelectionDialog._symbols_dir = os.path.dirname(path)
 
-        symbol_id = os.path.basename(path)
-        Controller.instance().post("/symbols/" + symbol_id + "/raw", qpartial(self._finishSymbolUpload, path), body=pathlib.Path(path), progressText="Uploading {}".format(symbol_id), timeout=None)
-
-    def _finishSymbolUpload(self, path, result, error=False, **kwargs):
-        if error:
-            log.error("Error while uploading symbol: {}: {}".format(path, result.get("message", "unknown")))
-            return
+        self._symbols_dir = os.path.dirname(path)
         self.uiSymbolLineEdit.clear()
         self.uiSymbolLineEdit.setText(path)
         self.uiSymbolLineEdit.setToolTip('<img src="{}"/>'.format(path))
@@ -208,9 +199,10 @@ class SymbolSelectionDialog(QtWidgets.QDialog, Ui_SymbolSelectionDialog):
         :param result: boolean (accepted or rejected)
         """
 
-        if result and self._items and not self._applyPreferencesSlot():
-            result = 0
+        if result:
+            if not self.uiSymbolListWidget.isEnabled() and not os.path.exists(self.uiSymbolLineEdit.text()):
+                QtWidgets.QMessageBox.critical(self, "Custom symbol", "Invalid path to custom symbol: {}".format(self.uiSymbolLineEdit.text()))
+                result = 0
+            elif result and self._items and not self._applyPreferencesSlot():
+                result = 0
         super().done(result)
-
-
-

gns3/dialogs/text_editor_dialog.py

@@ -19,7 +19,7 @@
 Text editor to edit Note items.
 """
 
-from ..qt import QtCore, QtWidgets, qslot, sip_is_deleted
+from ..qt import QtCore, QtWidgets
 from ..ui.text_editor_dialog_ui import Ui_TextEditorDialog
 
 
@@ -39,17 +39,17 @@ class TextEditorDialog(QtWidgets.QDialog, Ui_TextEditorDialog):
         self._items = items
         self.uiFontPushButton.clicked.connect(self._setFontSlot)
         self.uiColorPushButton.clicked.connect(self._setColorSlot)
-        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Apply).clicked.connect(self._applyPreferencesSlot)
+        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.Apply).clicked.connect(self._applyPreferencesSlot)
 
         # use the first item in the list as the model
         first_item = items[0]
         self._setColor(first_item.defaultTextColor())
-        self.uiRotationSpinBox.setValue(int(first_item.rotation()))
+        self.uiRotationSpinBox.setValue(first_item.rotation())
         self.uiPlainTextEdit.setPlainText(first_item.toPlainText())
         self.uiPlainTextEdit.setFont(first_item.font())
 
         if not first_item.editable():
-            self.uiPlainTextEdit.setTextInteractionFlags(QtCore.Qt.TextInteractionFlag.NoTextInteraction)
+            self.uiPlainTextEdit.setTextInteractionFlags(QtCore.Qt.NoTextInteraction)
 
         if len(self._items) == 1:
             self.uiApplyColorToAllItemsCheckBox.setChecked(True)
@@ -70,36 +70,30 @@ class TextEditorDialog(QtWidgets.QDialog, Ui_TextEditorDialog):
                                                                                  color.blue(),
                                                                                  color.alpha()))
 
-    @qslot
-    def _setFontSlot(self, *args):
+    def _setFontSlot(self):
         """
         Slot to select the font.
         """
 
-        selected_font, ok = QtWidgets.QFontDialog.getFont(self.uiPlainTextEdit.font(), self,
-                                                          options=QtWidgets.QFontDialog.FontDialogOption.DontUseNativeDialog)
+        selected_font, ok = QtWidgets.QFontDialog.getFont(self.uiPlainTextEdit.font(), self)
         if ok:
             self.uiPlainTextEdit.setFont(selected_font)
 
-    @qslot
-    def _setColorSlot(self, *args):
+    def _setColorSlot(self):
         """
         Slot to select the color.
         """
 
-        color = QtWidgets.QColorDialog.getColor(self._color, self, None, QtWidgets.QColorDialog.ColorDialogOption.ShowAlphaChannel)
+        color = QtWidgets.QColorDialog.getColor(self._color, self, None, QtWidgets.QColorDialog.ShowAlphaChannel)
         if color.isValid():
             self._setColor(color)
 
-    @qslot
-    def _applyPreferencesSlot(self, *args):
+    def _applyPreferencesSlot(self):
         """
         Applies the new text settings.
         """
 
         for item in self._items:
-            if sip_is_deleted(item):
-                continue
             item.setFont(self.uiPlainTextEdit.font())
             if self.uiApplyColorToAllItemsCheckBox.isChecked():
                 item.setDefaultTextColor(self._color)

gns3/dialogs/vm_with_images_wizard.py

@@ -18,7 +18,7 @@
 
 from .vm_wizard import VMWizard
 from gns3.qt import QtWidgets
-from gns3.controller import Controller
+from gns3.servers import Servers
 
 
 class VMWithImagesWizard(VMWizard):
@@ -26,17 +26,18 @@ class VMWithImagesWizard(VMWizard):
     Base class for VM wizard with image management (Qemu, IOU...)
 
     :param devices: List of existing device for this type
+    :param use_local_server: Value the use_local_server settings for this module
     :param parent: parent widget
     """
 
-    def __init__(self, devices, parent):
+    def __init__(self, devices, use_local_server, parent):
         # The list of images combo box (Qemu support multiple images)
         self._images_combo_boxes = set()
 
         # The list of radio button for existing image or new images
         self._radio_existing_images_buttons = set()
 
-        super().__init__(devices, parent)
+        super().__init__(devices, use_local_server, parent)
 
     def refreshImageStepsButtons(self):
         """
@@ -88,8 +89,10 @@ class VMWithImagesWizard(VMWizard):
         self._radio_existing_images_buttons.add(radio_button)
 
     def _imageCreateSlot(self, line_edit, create_image_wizard, image_suffix):
-        create_dialog = create_image_wizard(self, self.getSettings()["compute_id"], self.uiNameLineEdit.text() + image_suffix)
-        if QtWidgets.QDialog.DialogCode.Accepted == create_dialog.exec():
+        server = Servers.instance().getServerFromString(self.getSettings()["server"])
+
+        create_dialog = create_image_wizard(self, server, self.uiNameLineEdit.text() + image_suffix)
+        if QtWidgets.QDialog.Accepted == create_dialog.exec_():
             line_edit.setText(create_dialog.uiLocationLineEdit.text())
 
     def _imageBrowserSlot(self, line_edit, image_selector):
@@ -97,7 +100,8 @@ class VMWithImagesWizard(VMWizard):
         Slot to open a file browser and select an image.
         """
 
-        path = image_selector(self, self._compute_id)
+        server = Servers.instance().getServerFromString(self.getSettings()["server"])
+        path = image_selector(self, server)
         if not path:
             return
         line_edit.clear()
@@ -142,7 +146,7 @@ class VMWithImagesWizard(VMWizard):
         :param endpoint: server endpoint with the list of Images
         """
 
-        Controller.instance().getCompute(endpoint, self._compute_id, self._getImagesFromServerCallback)
+        self._server.get(endpoint, self._getImagesFromServerCallback)
 
     def _getImagesFromServerCallback(self, result, error=False, **kwargs):
         """
@@ -181,8 +185,10 @@ class VMWithImagesWizard(VMWizard):
                 for vm in result:
                     combo_box.addItem(vm["path"], vm)
 
+
     def _widgetOnCurrentPage(self, widget):
         """
         :returns Boolean True if widget is current active Wizard page
         """
         return self.currentPage().findChild(widget.__class__, widget.objectName()) is not None
+

gns3/dialogs/vm_wizard.py

@@ -18,8 +18,8 @@
 import sys
 
 from gns3.qt import QtWidgets
-from gns3.compute_manager import ComputeManager
-from gns3.controller import Controller
+from gns3.servers import Servers
+from gns3.gns3_vm import GNS3VM
 
 
 class VMWizard(QtWidgets.QWizard):
@@ -27,38 +27,37 @@ class VMWizard(QtWidgets.QWizard):
     Base class for VM wizard.
 
     :param devices: List of existing device for this type
+    :param use_local_server: Value the use_local_server settings for this module
     :param parent: parent widget
     """
 
-    def __init__(self, devices, parent):
+    def __init__(self, devices, use_local_server, parent):
         super().__init__(parent)
         self.setupUi(self)
 
         self.setModal(True)
 
         self._devices = devices
-        self._local_server_disable = False
+        self._use_local_server = use_local_server
 
-        self.setWizardStyle(QtWidgets.QWizard.WizardStyle.ModernStyle)
+        self.setWizardStyle(QtWidgets.QWizard.ModernStyle)
         if sys.platform.startswith("darwin"):
             # we want to see the cancel button on OSX
-            self.setOptions(QtWidgets.QWizard.WizardOption.NoDefaultButton)
+            self.setOptions(QtWidgets.QWizard.NoDefaultButton)
 
         self.uiRemoteRadioButton.toggled.connect(self._remoteServerToggledSlot)
         if hasattr(self, "uiVMRadioButton"):
             self.uiVMRadioButton.toggled.connect(self._vmToggledSlot)
 
         self.uiLocalRadioButton.toggled.connect(self._localToggledSlot)
-        if Controller.instance().isRemote():
-            self.uiLocalRadioButton.setText("Run device on the main server")
 
         # By default we use the local server
-        self._compute_id = "local"
+        self._server = Servers.instance().localServer()
         self.uiLocalRadioButton.setChecked(True)
         self._localToggledSlot(True)
 
-        if len(ComputeManager.instance().computes()) == 1:
-            # skip the server page if we use the first server
+        if Servers.instance().isNonLocalServerConfigured() is False:
+            # skip the server page if we use the local server
             self.setStartId(1)
 
     def _vmToggledSlot(self, checked):
@@ -93,29 +92,33 @@ class VMWizard(QtWidgets.QWizard):
             self.uiRemoteServersGroupBox.setEnabled(False)
             self.uiRemoteServersGroupBox.hide()
 
+    def setStartId(self, index):
+        """
+        Which page should we use when starting the Wizard
+        """
+        super().setStartId(index)
+        # If we skip the initial page (choosing a server)
+        # we check the settings
+        if index != 0:
+            self.uiLocalRadioButton.setChecked(True)
+
     def initializePage(self, page_id):
 
         if self.page(page_id) == self.uiServerWizardPage:
             self.uiRemoteServersComboBox.clear()
 
-            self.uiRemoteRadioButton.setEnabled(False)
-            if hasattr(self, "uiVMRadioButton"):
-                self.uiVMRadioButton.setEnabled(False)
-            self.uiLocalRadioButton.setEnabled(False)
-            for compute in ComputeManager.instance().computes():
-                if compute.id() == "local":
-                    self.uiLocalRadioButton.setEnabled(True)
-                elif compute.id() == "vm":
-                    if hasattr(self, "uiVMRadioButton"):
-                        self.uiVMRadioButton.setEnabled(True)
-                else:
-                    self.uiRemoteRadioButton.setEnabled(True)
-                    self.uiRemoteServersComboBox.addItem(compute.name(), compute.id())
+            if len(Servers.instance().remoteServers().values()) == 0:
+                self.uiRemoteRadioButton.setEnabled(False)
+            else:
+                for server in Servers.instance().remoteServers().values():
+                    self.uiRemoteServersComboBox.addItem(server.url(), server)
 
-            if self.uiLocalRadioButton.isEnabled() and not self._local_server_disable:
-                self.uiLocalRadioButton.setChecked(True)
-            elif hasattr(self, "uiVMRadioButton") and self.uiVMRadioButton.isEnabled():
+            if hasattr(self, "uiVMRadioButton") and not GNS3VM.instance().isRunning():
+                self.uiVMRadioButton.setEnabled(False)
+            if hasattr(self, "uiVMRadioButton") and GNS3VM.instance().isRunning():
                 self.uiVMRadioButton.setChecked(True)
+            elif self._use_local_server and self.uiLocalRadioButton.isEnabled():
+                self.uiLocalRadioButton.setChecked(True)
             else:
                 if self.uiRemoteRadioButton.isEnabled():
                     self.uiRemoteRadioButton.setChecked(True)
@@ -126,12 +129,15 @@ class VMWizard(QtWidgets.QWizard):
         """
         Turn off the local server
         """
-        self._local_server_disable = True
         self.uiLocalRadioButton.hide()
         self.uiLocalRadioButton.setEnabled(False)
         self.setStartId(0)
 
     def validateCurrentPage(self):
+        """
+        Validates the server.
+        """
+
         if hasattr(self, "uiNameWizardPage") and self.currentPage() == self.uiNameWizardPage:
             name = self.uiNameLineEdit.text()
             for device in self._devices.values():
@@ -139,21 +145,20 @@ class VMWizard(QtWidgets.QWizard):
                     QtWidgets.QMessageBox.critical(self, "Name", "{} is already used, please choose another name".format(name))
                     return False
         elif self.currentPage() == self.uiServerWizardPage:
-            # If the local button is not visible it's because it's not supported
-            if self.uiLocalRadioButton.isChecked() and self.uiLocalRadioButton.isHidden():
-                QtWidgets.QMessageBox.critical(self, "New device", "Please configure before the GNS3 VM in order to use this device.")
-                return False
-
             if self.uiRemoteRadioButton.isChecked():
-                if self.uiRemoteServersComboBox.count() == 0:
+                if not Servers.instance().remoteServers():
                     QtWidgets.QMessageBox.critical(self, "Remote server", "There is no remote server registered in your preferences")
                     return False
-                self._compute_id = self.uiRemoteServersComboBox.itemData(self.uiRemoteServersComboBox.currentIndex())
+                self._server = self.uiRemoteServersComboBox.itemData(self.uiRemoteServersComboBox.currentIndex())
             elif hasattr(self, "uiVMRadioButton") and self.uiVMRadioButton.isChecked():
-                self._compute_id = "vm"
+                gns3_vm_server = Servers.instance().vmServer()
+                if gns3_vm_server is None:
+                    QtWidgets.QMessageBox.critical(self, "GNS3 VM", "The GNS3 VM is not running")
+                    return False
+                self._server = gns3_vm_server
             else:
                 if self.uiLocalRadioButton.isEnabled():
-                    self._compute_id = "local"
+                    self._server = Servers.instance().localServer()
                 else:
                     QtWidgets.QMessageBox.critical(self, "Server", "No available server support this type of node. You probably need to setup the GNS3 VM")
                     return False

gns3/gns3_vm.py

@@ -0,0 +1,325 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 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/>.
+
+"""
+Manages the GNS3 VM.
+"""
+
+import os
+import sys
+import subprocess
+import codecs
+import shutil
+
+from .qt import QtNetwork
+from collections import OrderedDict
+from .servers import Servers
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class GNS3VM:
+
+    """
+    GNS3 VM management class.
+    """
+
+    def __init__(self):
+
+        self._is_running = False
+        # The current running vboxmanage and vmrun process
+        self._running_process = None
+
+    def settings(self):
+        """
+        Returns the GNS3 VM settings.
+
+        :returns: GNS3 VM settings (dict)
+        """
+
+        return Servers.instance().vmSettings()
+
+    def setSettings(self, settings):
+        """
+        Set new GNS3 VM settings.
+
+        :param settings: GNS3 VM settings (dict)
+        """
+
+        Servers.instance().setVMsettings(settings)
+
+    def killRunningProcess(self):
+        """
+        Kill the VBoxManage or vmrun process if running
+        """
+
+        if self._running_process is not None:
+            self._running_process.kill()
+            self._running_process.wait()
+            self._running_process = None
+
+    def _process_check_output(self, command, timeout=None):
+        # Original code from Python's subprocess.check_output
+        # https://github.com/python/cpython/blob/3.4/Lib/subprocess.py
+        with subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=os.environ) as process:
+            self._running_process = process
+            try:
+                output, unused_err = process.communicate(None, timeout=timeout)
+            except subprocess.TimeoutExpired:
+                process.kill()
+                output, unused_err = process.communicate()
+                self._running_process = None
+                raise subprocess.TimeoutExpired(process.args, timeout, output=output)
+            except:
+                self.killRunningProcess()
+                raise
+            retcode = process.poll()
+            if retcode:
+                self._running_process = None
+                raise subprocess.CalledProcessError(retcode, process.args, output=output)
+        self._running_process = None
+        return output.decode("utf-8", errors="ignore").strip()
+
+    def execute_vmrun(self, subcommand, args, timeout=60):
+
+        from gns3.modules.vmware import VMware
+        vmware_settings = VMware.instance().settings()
+        vmrun_path = vmware_settings["vmrun_path"]
+        if sys.platform.startswith("darwin"):
+            command = [vmrun_path, "-T", "fusion", subcommand]
+        else:
+            host_type = vmware_settings["host_type"]
+            command = [vmrun_path, "-T", host_type, subcommand]
+        command.extend(args)
+        log.debug("Executing vmrun with command: {}".format(command))
+        return self._process_check_output(command, timeout=timeout)
+
+    def execute_vboxmanage(self, subcommand, args, timeout=60):
+
+        from gns3.modules.virtualbox import VirtualBox
+        virtualbox_settings = VirtualBox.instance().settings()
+        vboxmanage_path = virtualbox_settings["vboxmanage_path"]
+        command = [vboxmanage_path, "--nologo", subcommand]
+        command.extend(args)
+        log.debug("Executing VBoxManage with command: {}".format(command))
+        return self._process_check_output(command, timeout=timeout)
+
+    @staticmethod
+    def parse_vmx_file(path):
+        """
+        Parses a VMX file.
+
+        :param path: path to the VMX file
+
+        :returns: dict
+        """
+
+        pairs = OrderedDict()
+        encoding = "utf-8"
+        # get the first line to read the .encoding value
+        with open(path, "rb") as f:
+            line = f.readline().decode(encoding, errors="ignore")
+            if line.startswith("#!"):
+                # skip the shebang
+                line = f.readline().decode(encoding, errors="ignore")
+            try:
+                key, value = line.split('=', 1)
+                if key.strip().lower() == ".encoding":
+                    file_encoding = value.strip('" ')
+                    try:
+                        codecs.lookup(file_encoding)
+                        encoding = file_encoding
+                    except LookupError:
+                        log.warning("Invalid file encoding detected in '{}': {}".format(path, file_encoding))
+            except ValueError:
+                log.warning("Couldn't find file encoding in {}, using {}...".format(path, encoding))
+
+        # read the file with the correct encoding
+        with open(path, encoding=encoding, errors="ignore") as f:
+            for line in f.read().splitlines():
+                try:
+                    key, value = line.split('=', 1)
+                    pairs[key.strip().lower()] = value.strip('" ')
+                except ValueError:
+                    continue
+        return pairs
+
+    @staticmethod
+    def write_vmx_file(path, pairs):
+        """
+        Write a VMware VMX file.
+
+        :param path: path to the VMX file
+        :param pairs: settings to write
+        """
+
+        encoding = "utf-8"
+        if ".encoding" in pairs:
+            file_encoding = pairs[".encoding"]
+            try:
+                codecs.lookup(file_encoding)
+                encoding = file_encoding
+            except LookupError:
+                log.warning("Invalid file encoding detected in '{}': {}".format(path, file_encoding))
+        with open(path, "w", encoding=encoding, errors="ignore") as f:
+            if sys.platform.startswith("linux"):
+                # write the shebang on the first line on Linux
+                vmware_path = shutil.which("vmware")
+                if vmware_path:
+                    f.write("#!{}\n".format(vmware_path))
+            for key, value in pairs.items():
+                entry = '{} = "{}"\n'.format(key, value)
+                f.write(entry)
+
+    def autoStart(self):
+        """
+        Automatically start the GNS3 VM at startup.
+
+        :returns: boolean
+        """
+
+        vm_settings = Servers.instance().vmSettings()
+        return vm_settings["auto_start"]
+
+    def isRemote(self):
+        """
+        Checks if the GNS3 VM is remote.
+
+        :returns: boolean
+        """
+
+        vm_settings = Servers.instance().vmSettings()
+        if vm_settings["virtualization"] == "remote":
+            return True
+        return False
+
+    def adjustLocalServerIP(self):
+        """
+        Adjust the local server IP address to be in the same subnet as the GNS3 VM.
+
+        :returns: the local server IP/host address
+        """
+
+        servers = Servers.instance()
+        local_server_settings = servers.localServerSettings()
+        if Servers.instance().vmSettings()["adjust_local_server_ip"]:
+            vm_server = servers.vmServer()
+            vm_ip_address = vm_server.host()
+            log.debug("GNS3 VM IP address is {}".format(vm_ip_address))
+
+            for interface in QtNetwork.QNetworkInterface.allInterfaces():
+                for address in interface.addressEntries():
+                    ip = address.ip().toString()
+                    prefix_length = address.prefixLength()
+                    subnet = QtNetwork.QHostAddress.parseSubnet("{}/{}".format(ip, prefix_length))
+                    if QtNetwork.QHostAddress(vm_ip_address).isInSubnet(subnet):
+                        if local_server_settings["host"] != ip:
+                            log.info("Adjust local server IP address to {}".format(ip))
+                            servers.setLocalServerSettings({"host": ip})
+                            servers.registerLocalServer()
+                            servers.save()
+                            return ip
+        return local_server_settings["host"]
+
+    def setRunning(self, value):
+        """
+        Sets either the GNS3 VM is running or not.
+
+        :param value: boolean
+        """
+
+        self._is_running = value
+
+    def isRunning(self):
+        """
+        Returns either the GNS3 VM is running or not.
+
+        :returns: boolean
+        """
+
+        return self._is_running
+
+    def setvCPUandRAM(self, vcpus, ram):
+        """
+        Set the vCPU cores and RAM amount for the GNS3 VM.
+
+        :param vcpus: number of vCPU cores
+        :param ram: amount of memory
+
+        :returns: boolean
+        """
+
+        vm_settings = self.settings()
+        if vm_settings["virtualization"] == "VMware":
+            try:
+                pairs = self.parse_vmx_file(vm_settings["vmx_path"])
+                pairs["numvcpus"] = str(vcpus)
+                pairs["memsize"] = str(ram)
+                self.write_vmx_file(vm_settings["vmx_path"], pairs)
+            except OSError as e:
+                log.error('Could not read/write VMware VMX file "{}": {}'.format(vm_settings["vmx_path"], e))
+                return False
+
+        elif vm_settings["virtualization"] == "VirtualBox":
+            try:
+                self.execute_vboxmanage("modifyvm", [vm_settings["vmname"], "--cpus", str(vcpus)], timeout=3)
+                self.execute_vboxmanage("modifyvm", [vm_settings["vmname"], "--memory", str(ram)], timeout=3)
+            except OSError as e:
+                log.error("Could not execute VBoxManage: {}".format(e), True)
+                return False
+            except subprocess.SubprocessError as e:
+                log.error("Could not execute VBoxManage: {} with output '{}'".format(e, e.output.decode("utf-8", errors="ignore").strip()), True)
+                return False
+            except subprocess.TimeoutExpired:
+                log.error("VBoxmanage timeout expired", True)
+                return False
+        log.info("GNS3 VM vCPU count set to {} and RAM to {} MB".format(vcpus, ram))
+        return True
+
+    def shutdown(self, force=False):
+        """
+        Gracefully shutdowns the GNS3 VM.
+        """
+
+        vm_settings = self.settings()
+        if self._is_running and (vm_settings["auto_stop"] or force):
+            try:
+                if vm_settings["virtualization"] == "VMware":
+                    if vm_settings["vmx_path"] is None:
+                        log.error("No vm path configured, can't stop the VM")
+                        return
+                    self.execute_vmrun("stop", [vm_settings["vmx_path"], "soft"])
+                elif vm_settings["virtualization"] == "VirtualBox":
+                    self.execute_vboxmanage("controlvm", [vm_settings["vmname"], "acpipowerbutton"], timeout=3)
+            except (OSError, subprocess.SubprocessError):
+                pass
+            except subprocess.TimeoutExpired:
+                log.warning("Could not ACPI shutdown the VM (timeout expired)")
+        self._is_running = False
+
+    @staticmethod
+    def instance():
+        """
+        Singleton to return only on instance of GNS3VM
+
+        :returns: instance of GNS3VM
+        """
+
+        if not hasattr(GNS3VM, "_instance") or GNS3VM._instance is None:
+            GNS3VM._instance = GNS3VM()
+        return GNS3VM._instance

gns3/image_manager.py

@@ -16,16 +16,13 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import os
-import copy
 import pathlib
+import glob
 
+from gns3.servers import Servers
 from gns3.qt import QtWidgets
-from gns3.local_server_config import LocalServerConfig
-from gns3.settings import LOCAL_SERVER_SETTINGS
-from gns3.controller import Controller
 from gns3.utils.file_copy_worker import FileCopyWorker
 from gns3.utils.progress_dialog import ProgressDialog
-from gns3.registry.image import Image
 
 
 class ImageManager:
@@ -34,29 +31,7 @@ class ImageManager:
         # Remember if we already ask the user about this image for this server
         self._asked_for_this_image = {}
 
-    def _getUniqueDestinationPath(self, source_image, node_type, path):
-        """
-        Get a unique destination path (with counter).
-        """
-
-        if not os.path.exists(path):
-            return path
-        path, extension = os.path.splitext(path)
-        counter = 1
-        new_path = "{}-{}{}".format(path, counter, extension)
-        while os.path.exists(new_path):
-            destination_image = Image(node_type, new_path, filename=os.path.basename(new_path))
-            try:
-                if source_image.md5sum == destination_image.md5sum:
-                    # the source and destination images are identical
-                    return new_path
-            except OSError:
-                continue
-            counter += 1
-            new_path = "{}-{}{}".format(path, counter, extension)
-        return new_path
-
-    def askCopyUploadImage(self, parent, source_path, server, node_type):
+    def askCopyUploadImage(self, parent, path, server, vm_type):
         """
         Ask user for copying the image to the default directory or upload
         it to remote server.
@@ -64,94 +39,116 @@ class ImageManager:
         :param parent: Parent window
         :param path: File path on computer
         :param server: The server where the images should be located
-        :param node_type: Remote upload endpoint
+        :param vm_type: Remote upload endpoint
         :returns path: Final path
         """
 
-        if (server and server != "local") or Controller.instance().isRemote():
-            return self._uploadImageToRemoteServer(source_path, server, node_type)
+        if server and not server.isLocal():
+            return self._uploadImageToRemoteServer(path, server, vm_type)
         else:
-            destination_directory = self.getDirectoryForType(node_type)
-            destination_path = os.path.join(destination_directory, os.path.basename(source_path))
-            source_filename = os.path.basename(source_path)
-            destination_filename = os.path.basename(destination_path)
-            if os.path.normpath(os.path.dirname(source_path)) != destination_directory:
-                # the image is not in the default images directory
-                if source_filename == destination_filename:
-                    # the filename already exists in the default images directory
-                    source_image = Image(node_type, source_path, filename=source_filename)
-                    destination_image = Image(node_type, destination_path, filename=destination_filename)
-                    try:
-                        if source_image.md5sum == destination_image.md5sum:
-                            # the source and destination images are identical
-                            return source_path
-                    except OSError as e:
-                        QtWidgets.QMessageBox.critical(parent, 'Image', 'Cannot compare image file {} with {}: {}.'.format(source_path, destination_path, str(e)))
-                        return source_path
-                    # find a new unique path to avoid overwriting existing destination file
-                    destination_path = self._getUniqueDestinationPath(source_image, node_type, destination_path)
-
+            destination_directory = self.getDirectoryForType(vm_type)
+            if os.path.normpath(os.path.dirname(path)) != destination_directory:
+                # the IOS image is not in the default images directory
                 reply = QtWidgets.QMessageBox.question(parent,
                                                        'Image',
-                                                       'Would you like to copy {} to the default images directory'.format(source_filename),
-                                                       QtWidgets.QMessageBox.StandardButton.Yes,
-                                                       QtWidgets.QMessageBox.StandardButton.No)
-                if reply == QtWidgets.QMessageBox.StandardButton.Yes:
+                                                       'Would you like to copy {} to the default images directory'.format(os.path.basename(path)),
+                                                       QtWidgets.QMessageBox.Yes,
+                                                       QtWidgets.QMessageBox.No)
+                if reply == QtWidgets.QMessageBox.Yes:
+                    destination_path = os.path.join(destination_directory, os.path.basename(path))
                     try:
                         os.makedirs(destination_directory, exist_ok=True)
                     except OSError as e:
                         QtWidgets.QMessageBox.critical(parent, 'Image', 'Could not create destination directory {}: {}'.format(destination_directory, str(e)))
-                        return source_path
-
-                    worker = FileCopyWorker(source_path, destination_path)
-                    progress_dialog = ProgressDialog(worker, 'Image', 'Copying {}'.format(source_filename), 'Cancel', busy=True, parent=parent)
+                        return path
+                    worker = FileCopyWorker(path, destination_path)
+                    progress_dialog = ProgressDialog(worker, 'Image', 'Copying {}'.format(os.path.basename(path)), 'Cancel', busy=True, parent=parent)
                     progress_dialog.show()
-                    progress_dialog.exec()
+                    progress_dialog.exec_()
                     errors = progress_dialog.errors()
                     if errors:
                         QtWidgets.QMessageBox.critical(parent, 'Image', '{}'.format(''.join(errors)))
-                        return source_path
+                        return path
                     else:
-                        source_path = destination_path
-            return source_path
+                        path = destination_path
+            return path
 
-    def _uploadImageToRemoteServer(self, path, server, node_type):
+    def _uploadImageToRemoteServer(self, path, server, vm_type):
         """
         Upload image to remote server
 
         :param path: File path on computer
         :param server: The server where the images should be located
-        :param node_type: Image node_type
+        :param vm_type: Image vm_type
         :returns path: Final path
         """
 
-        if node_type == 'QEMU':
-            upload_endpoint = '/qemu/images'
-        elif node_type == 'IOU':
-            upload_endpoint = '/iou/images'
-        elif node_type == 'DYNAMIPS':
-            upload_endpoint = '/dynamips/images'
+        if vm_type == 'QEMU':
+            upload_endpoint = '/qemu/vms'
+        elif vm_type == 'IOU':
+            upload_endpoint = '/iou/vms'
+        elif vm_type == 'DYNAMIPS':
+            upload_endpoint = '/dynamips/vms'
         else:
-            raise Exception('Invalid node type')
+            raise Exception('Invalid image vm_type')
 
-        filename = self._getRelativeImagePath(path, node_type).replace("\\", "/")
-        Controller.instance().postCompute('{}/{}'.format(upload_endpoint, filename), server, None, body=pathlib.Path(path), progressText="Uploading {}".format(filename), timeout=None)
+        filename = self._getRelativeImagePath(path, vm_type).replace("\\", "/")
+        server.post('{}/{}'.format(upload_endpoint, filename), None, body=pathlib.Path(path), progressText="Uploading {}".format(filename), timeout=None)
         return filename
 
-    def _getRelativeImagePath(self, path, node_type):
+    def addMissingImage(self, filename, server, vm_type):
+        """
+        Add a missing image to the queue of images require to be upload on remote server
+        :param filename: Filename of the image
+        :param server: Server where image should be uploaded
+        :param vm_type: Type of the image
+        """
+
+        if self._asked_for_this_image.setdefault(server.id(), {}).setdefault(filename, False):
+            return
+        self._asked_for_this_image[server.id()][filename] = True
+
+        if server.isLocal():
+            return
+        path = os.path.join(self.getDirectoryForType(vm_type), filename)
+        if os.path.exists(path):
+            if self._askForUploadMissingImage(filename, server):
+
+                if filename.endswith(".vmdk"):
+                    # A vmdk file could be split in multiple vmdk file
+                    search = glob.escape(path).replace(".vmdk", "-*.vmdk")
+                    for file in glob.glob(search):
+                        self._uploadImageToRemoteServer(file, server, vm_type)
+
+                self._uploadImageToRemoteServer(path, server, vm_type)
+                del self._asked_for_this_image[server.id()][filename]
+
+    def _askForUploadMissingImage(self, filename, server):
+        from gns3.main_window import MainWindow
+        parent = MainWindow.instance()
+        reply = QtWidgets.QMessageBox.warning(parent,
+                                              'Image',
+                                              '{} is missing on server {} but exist on your computer. Do you want to upload it?'.format(filename, server.url()),
+                                              QtWidgets.QMessageBox.Yes,
+                                              QtWidgets.QMessageBox.No)
+        if reply == QtWidgets.QMessageBox.Yes:
+            return True
+        return False
+
+    def _getRelativeImagePath(self, path, vm_type):
         """
         Get a path relative to images directory path
         or just filename if the path is not located inside
         image directory
 
         :param path: file path
-        :param node_type: Type of vm
+        :param vm_type: Type of vm
         :return: file path
         """
 
         if not path:
             return ""
-        img_directory = self.getDirectoryForType(node_type)
+        img_directory = self.getDirectoryForType(vm_type)
         path = os.path.abspath(path)
         if os.path.commonprefix([img_directory, path]) == img_directory:
             return os.path.relpath(path, img_directory)
@@ -164,19 +161,19 @@ class ImageManager:
         :returns: path to the default images directory
         """
 
-        return copy.copy(LocalServerConfig.instance().loadSettings("Server", LOCAL_SERVER_SETTINGS)['images_path'])
+        return Servers.instance().localServerSettings()['images_path']
 
-    def getDirectoryForType(self, node_type):
+    def getDirectoryForType(self, vm_type):
         """
         Return the path of local directory of the images
-        of a specific node_type
+        of a specific vm_type
 
-        :param node_type: Type of vm
+        :param vm_type: Type of vm
         """
-        if node_type == 'DYNAMIPS':
+        if vm_type == 'DYNAMIPS':
             return os.path.join(self.getDirectory(), 'IOS')
         else:
-            return os.path.join(self.getDirectory(), node_type.upper())
+            return os.path.join(self.getDirectory(), vm_type)
 
     @staticmethod
     def instance():

gns3/image_upload_manager.py

@@ -1,90 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2017 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 os
-import pathlib
-import urllib.parse
-
-from gns3.http_client import HTTPClient
-
-import logging
-log = logging.getLogger(__name__)
-
-
-class ImageUploadManager(object):
-    """
-    Manager over the image upload. Encapsulates file uploads to computes or via controller.
-    """
-
-    def __init__(self, image, controller, compute_id, callback=None, directFileUpload=False):
-        self._image = image
-        self._compute_id = compute_id
-        self._callback = callback
-        self._directFileUpload = directFileUpload
-        self._controller = controller
-
-    def upload(self):
-        if not os.path.exists(self._image.path):
-            log.error("Image '{}' could not be found".format(self._image.path))
-            return
-        if self._directFileUpload:
-            # first obtain endpoint and know when target request
-            self._controller.getEndpoint(self._getComputePath(), self._compute_id, self._onLoadEndpointCallback, showProgress=False)
-        else:
-            self._fileUploadToController()
-
-    def _getComputePath(self):
-        return '/{emulator}/images/{filename}'.format(emulator=self._image.emulator, filename=self._image.filename)
-
-    def _onLoadEndpointCallback(self, result, error=False, **kwargs):
-        if error:
-            if "message" in result:
-                log.error("Error while getting endpoint: {}".format(result["message"]))
-            return
-
-        # we know where is the endpoint and we trying to post there a file
-        endpoint = result['endpoint']
-        self._fileUploadToCompute(endpoint)
-
-    def _checkIfSuccessfulCallback(self, result, error=False, **kwargs):
-        if error:
-            connection_error = kwargs.get('connection_error', False)
-            if connection_error:
-                log.debug("During direct file upload compute is not visible. Fallback to upload via controller.")
-                # there was an issue with connection, probably we don't have a direct access to compute
-                # we need to fallback to uploading files via controller
-                self._fileUploadToController()
-            else:
-                if "message" in result:
-                    log.error("Error while direct file upload: {}".format(result["message"]))
-            return
-        self._callback(result, error, **kwargs)
-
-    def _fileUploadToCompute(self, endpoint):
-        log.debug("Uploading image '{}' to compute".format(self._image.path))
-        parse_results = urllib.parse.urlparse(endpoint)
-        network_manager = self._controller.getHttpClient().getNetworkManager()
-        client = HTTPClient.fromUrl(endpoint, network_manager=network_manager)
-        # We don't retry connection as in case of fail we try direct file upload
-        client.setMaxRetryConnection(0)
-        client.createHTTPQuery('POST', parse_results.path, self._checkIfSuccessfulCallback, body=pathlib.Path(self._image.path),
-                               context={"image_path": self._image.path}, progressText="Uploading {}".format(self._image.filename), timeout=None, prefix="")
-
-    def _fileUploadToController(self):
-        log.debug("Uploading image '{}' to controller".format(self._image.path))
-        self._controller.postCompute(self._getComputePath(), self._compute_id, self._callback, body=pathlib.Path(self._image.path),
-                                     context={"image_path": self._image.path}, progressText="Uploading {}".format(self._image.filename), timeout=None)

gns3/iouvm_converter.py

@@ -0,0 +1,189 @@
+#!/usr/bin/env python
+#
+# 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 sys
+import shutil
+import json
+import os
+from datetime import datetime
+
+
+try:
+    from gns3.qt import QtGui, QtWidgets
+except ImportError:
+    raise SystemExit("Can't import Qt modules: Qt and/or PyQt is probably not installed correctly...")
+
+import logging
+log = logging.getLogger(__name__)
+
+
+from gns3.version import __version__
+from gns3.local_config import LocalConfig
+from gns3.ui.iouvm_converter_wizard_ui import Ui_IOUVMConverterWizard
+
+
+class IOUVMConverterWizard(QtWidgets.QWizard, Ui_IOUVMConverterWizard):
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setupUi(self)
+        self.setWizardStyle(QtWidgets.QWizard.ModernStyle)
+        if sys.platform.startswith("darwin"):
+            # we want to see the cancel button on OSX
+            self.setOptions(QtWidgets.QWizard.NoDefaultButton)
+
+        # set the window icon
+        self.setWindowIcon(QtGui.QIcon(":/images/gns3.ico"))  # this info is necessary for QSettings
+
+        config = self._loadConfig()
+        self.uiPushButtonBrowse.clicked.connect(self._browseTopologiesSlot)
+        self.uiLineEditTopologiesPath.setText(config['Servers']['local_server']['projects_path'])
+
+    def _browseTopologiesSlot(self):
+        path = QtWidgets.QFileDialog.getExistingDirectory(self, 'Select a directory')
+        self.uiLineEditTopologiesPath.setText(path)
+
+    def validateCurrentPage(self):
+        """
+        Validates the settings.
+        """
+
+        if self.currentPage() == self.uiWizardPageIOURCCheck:
+            return self._checkIOURC()
+        elif self.currentPage() == self.uiWizardUpdateConfiguration:
+            return self._updateConfig()
+        elif self.currentPage() == self.uiWizardPagePatchTopologies:
+            return self._patchTopologies()
+        return True
+
+    def _checkIOURC(self):
+        """
+        Validate if the IOURC contain an entry for the IOUVM
+        """
+        config = self._loadConfig()
+        iourc_path = config.get("IOU", {}).get("iourc_path", "")
+        if len(iourc_path) == 0:
+            QtWidgets.QMessageBox.critical(self, "Error", "The IOURC is not configured")
+            return False
+        try:
+            with open(iourc_path) as f:
+                if 'gns3vm' not in f.read():
+                    QtWidgets.QMessageBox.critical(self, "Error", "The gns3vm doesn't exist in your iourc file".format(iourc_path))
+        except OSError:
+            QtWidgets.QMessageBox.critical(self, "Error", "IOURC file {} doesn't exist or not accessible".format(iourc_path))
+        return True
+
+    def _updateConfig(self):
+        """
+        Update the config file to use the GNS3 VM instead of IOU VM
+        """
+        config = self._loadConfig()
+        if "devices" in config["IOU"]:
+            for device in config["IOU"]["devices"]:
+                device["path"] = os.path.basename(device["path"])
+                device["server"] = "vm"
+        config["Servers"]["remote_servers"] = []
+        self._writeConfig(config)
+        return True
+
+    def _patchTopologies(self):
+        """
+        Patch topologies to use the GNS3 VM
+        """
+
+        path = self.uiLineEditTopologiesPath.text()
+        try:
+            for (dirpath, dirnames, filenames) in os.walk(path):
+                for filename in filenames:
+                    if filename.endswith(".gns3"):
+                        self._patchTopology(os.path.join(dirpath, filename))
+        except OSError as e:
+            QtWidgets.QMessageBox.critical(self, "Error", "Can't open {}: {}".format(path, str(e)))
+            return False
+        return True
+
+    def _patchTopology(self, path):
+        """
+        Path a specific topology
+        """
+        try:
+            shutil.copy(path, "{}.{}.backup".format(path, datetime.now().isoformat()))
+            with open(path) as f:
+                topo = json.load(f)
+            if "topology" in topo and "servers" in topo["topology"]:
+                for server in topo["topology"]["servers"]:
+                    if server["local"] is False:
+                        server["vm"] = True
+                with open(path, 'w+') as f:
+                    topo = json.dump(topo, f)
+        except OSError as e:
+            QtWidgets.QMessageBox.critical(self, "Error", "Can't open {}: {}".format(path, str(e)))
+
+    def _loadConfig(self):
+        with open(self._configurationFile()) as f:
+            return json.load(f)
+
+    def _writeConfig(self, config):
+        shutil.copy(self._configurationFile(), "{}.{}.backup".format(self._configurationFile(), datetime.now().isoformat()))
+        with open(self._configurationFile(), 'w+') as f:
+            json.dump(config, f, indent=4)
+
+    def _configurationFile(self):
+        if sys.platform.startswith("win"):
+            filename = "gns3_gui.ini"
+        else:
+            filename = "gns3_gui.conf"
+        directory = LocalConfig.configDirectory()
+        return os.path.join(directory, filename)
+
+
+def main():
+    app = QtWidgets.QApplication(sys.argv)
+
+    app.setOrganizationName("GNS3")
+    app.setOrganizationDomain("gns3.net")
+    app.setApplicationName("GNS3")
+    app.setApplicationVersion(__version__)
+
+    # We force a full garbage collect before exit
+    # for unknow reason otherwise Qt Segfault on OSX in some
+    # conditions
+    import gc
+    gc.collect()
+
+    # Manage Ctrl + C or kill command
+    def sigint_handler(*args):
+        log.info("Signal received exiting the application")
+        app.closeAllWindows()
+    # signal.signal(signal.SIGINT, sigint_handler)
+    # signal.signal(signal.SIGTERM, sigint_handler)
+
+    mainwindow = IOUVMConverterWizard()
+    mainwindow.show()
+    exit_code = mainwindow.exec_()
+
+    # We force a full garbage collect before exit
+    # for unknow reason otherwise Qt Segfault on OSX in some
+    # conditions
+    import gc
+    gc.collect()
+
+    sys.exit(exit_code)
+
+if __name__ == '__main__':
+    main()

gns3/items/drawing_item.py

@@ -1,316 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright (C) 2016 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/>.
-
-from ..qt import QtCore, QtWidgets, qslot, QtGui
-from .utils import colorFromSvg
-
-import uuid
-import logging
-import binascii
-log = logging.getLogger(__name__)
-
-
-class DrawingItem:
-    # Map QT stroke to SVG style
-    QT_DASH_TO_SVG = {
-        QtCore.Qt.PenStyle.SolidLine: "",
-        QtCore.Qt.PenStyle.NoPen: None,
-        QtCore.Qt.PenStyle.DashLine: "25, 25",
-        QtCore.Qt.PenStyle.DotLine: "5, 25",
-        QtCore.Qt.PenStyle.DashDotLine: "5, 25, 25",
-        QtCore.Qt.PenStyle.DashDotDotLine: "25, 25, 5, 25, 5"
-    }
-
-    show_layer = False
-
-    """
-    Base class for non emulation item
-    """
-
-    def __init__(self, project=None, pos=None, drawing_id=None, svg=None, z=0, locked=False, rotation=0, **kws):
-        self._id = drawing_id
-        self._deleting = False
-        self._allow_snap_to_grid = True
-        self._locked = locked
-        if self._id is None:
-            self._id = str(uuid.uuid4())
-        self.setFlags(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable | QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsFocusable | QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsSelectable | QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemSendsGeometryChanges)
-
-        from ..main_window import MainWindow
-        self._graphics_view = MainWindow.instance().uiGraphicsView
-        self._main_window = MainWindow.instance()
-
-        self._project = project
-
-        # Store a hash of the SVG to avoid him
-        # to be sent if he doesn't change
-        self._hash_svg = None
-
-        if pos:
-            self.setPos(pos)
-        if z:
-            self.setZValue(z)
-        if rotation:
-            self.setRotation(rotation)
-
-        self.setLocked(locked)
-
-    def drawing_id(self):
-        return self._id
-
-    def create(self):
-        if self._project:
-            self._project.post("/drawings", self._createDrawingCallback, body=self.__json__())
-
-    def _createDrawingCallback(self, result, error=False, **kwargs):
-        """
-        Callback for create.
-
-        :param result: server response
-        :param error: indicates an error (boolean)
-        :returns: Boolean success or not
-        """
-
-        if error:
-            log.error("Error while creating drawing: {}".format(result["message"]))
-            return False
-        self._id = result["drawing_id"]
-        self.updateDrawingCallback(result)
-
-    def updateDrawing(self):
-        if self._id and not self.deleting() and self._project:
-            self._project.put("/drawings/" + self._id, self.updateDrawingCallback, body=self.__json__(), showProgress=False)
-
-    @qslot
-    def updateDrawingCallback(self, result, error=False, **kwargs):
-        """
-        Callback for update.
-
-        :param result: server response
-        :param error: indicates an error (boolean)
-        :returns: Boolean success or not
-        """
-
-        if error:
-            if "doesn't exist" in result.get("message", ""):
-                log.warning("Drawing not found on server, recreating: {}".format(self._id))
-                self._id = None
-                self.create()
-                return True
-            log.error("Error while updating drawing: {}".format(result["message"]))
-            return False
-        self.setPos(QtCore.QPointF(result["x"], result["y"]))
-        self.setZValue(result["z"])
-        self.setLocked(result["locked"])
-        self.setRotation(result["rotation"])
-        if "svg" in result:
-            self.fromSvg(result["svg"])
-
-    def handleKeyPressEvent(self, event):
-        """
-        Handles all key press events
-
-        :param event: QKeyEvent
-        :return: Boolean True the event has been captured
-        """
-        key = event.key()
-        modifiers = event.modifiers()
-        if key in (QtCore.Qt.Key.Key_P, QtCore.Qt.Key.Key_Plus, QtCore.Qt.Key.Key_Equal) and modifiers & QtCore.Qt.KeyboardModifier.AltModifier \
-                or key == QtCore.Qt.Key.Key_Plus and modifiers & QtCore.Qt.KeyboardModifier.AltModifier and modifiers & QtCore.Qt.KeyboardModifier.KeypadModifier:
-            if self.rotation() == 0:
-                self.setRotation(359)
-            else:
-                self.setRotation(self.rotation() - 1)
-            return True
-        elif key in (QtCore.Qt.Key.Key_M, QtCore.Qt.Key.Key_Minus) and modifiers & QtCore.Qt.KeyboardModifier.AltModifier \
-                or key == QtCore.Qt.Key.Key_Minus and modifiers & QtCore.Qt.KeyboardModifier.AltModifier and modifiers & QtCore.Qt.KeyboardModifier.KeypadModifier:
-            if self.rotation() < 360.0:
-                self.setRotation(self.rotation() + 1)
-                return True
-        elif modifiers & QtCore.Qt.KeyboardModifier.AltModifier:
-            self._allow_snap_to_grid = False
-            return True
-        return False
-
-    def keyPressEvent(self, event):
-        """
-        Handles all key press events
-
-        :param event: QKeyEvent
-        """
-
-        if not self.handleKeyPressEvent(event):
-            QtWidgets.QGraphicsItem.keyPressEvent(self, event)
-
-    def keyReleaseEvent(self, event):
-        """
-        Handles all key release events
-
-        :param event: QKeyEvent
-        """
-
-        self._allow_snap_to_grid = True
-
-    def __json__(self):
-        data = {
-            "drawing_id": self._id,
-            "x": int(self.pos().x()),
-            "y": int(self.pos().y()),
-            "z": int(self.zValue()),
-            "locked": self._locked,
-            "rotation": int(self.rotation())
-        }
-        svg = self.toSvg()
-        hash_svg = binascii.crc32(svg.encode())
-        if hash_svg != self._hash_svg:
-            data["svg"] = svg
-            self._hash_svg = hash_svg
-        return data
-
-    def locked(self):
-        """
-        Is the drawing locked
-        """
-
-        return self._locked
-
-    def setLocked(self, locked):
-        """
-        Sets the locked value.
-
-        :param value: Z value
-        """
-
-        if locked is True:
-            self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable, False)
-        else:
-            self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable, True)
-        self._locked = locked
-
-    def deleting(self):
-        """
-        Is the drawing being deleted
-        """
-
-        return self._deleting
-
-    def setDeleting(self):
-        """
-        Mark this drawing as being deleted
-        """
-
-        self._deleting = True
-
-    def delete(self, skip_controller=False):
-        """
-        Deletes this drawing.
-
-        :param skip_controller: Do not replicate change on the controller (useful when it's already deleted on controller)
-        """
-
-        self.setDeleting()
-        self.scene().removeItem(self)
-        from ..topology import Topology
-        Topology.instance().removeDrawing(self)
-        if self._id and not skip_controller:
-            self._project.delete("/drawings/" + self._id, None)
-
-    def itemChange(self, change, value):
-
-        if change == QtWidgets.QGraphicsItem.GraphicsItemChange.ItemPositionChange and self._main_window.uiSnapToGridAction.isChecked() \
-                and self._allow_snap_to_grid:
-            grid_size = self._graphics_view.drawingGridSize()
-            mid_x = self.boundingRect().width() / 2
-            value.setX((grid_size * round((value.x() + mid_x) / grid_size)) - mid_x)
-            mid_y = self.boundingRect().height() / 2
-            value.setY((grid_size * round((value.y()+mid_y)/grid_size)) - mid_y)
-
-        if change == QtWidgets.QGraphicsItem.GraphicsItemChange.ItemSelectedChange:
-            if not value:
-                self.updateDrawing()
-        return QtWidgets.QGraphicsItem.itemChange(self, change, value)
-
-    def updateNode(self):
-        self.updateDrawing()
-
-    def drawLayerInfo(self, painter):
-        """
-        Draws the layer position.
-
-        :param painter: QPainter instance
-        """
-
-        if self.show_layer is False:
-            return
-
-        brect = self.boundingRect()
-        # don't draw anything if the object is too small
-        if brect.width() < 20 or brect.height() < 20:
-            return
-
-        center = self.mapFromItem(self, brect.width() / 2.0, brect.height() / 2.0)
-        painter.setBrush(QtCore.Qt.GlobalColor.red)
-        painter.setPen(QtCore.Qt.GlobalColor.red)
-        painter.drawRect(QtCore.QRectF((brect.width() / 2.0) - 10, (brect.height() / 2.0) - 10, 20, 20))
-        painter.setPen(QtCore.Qt.GlobalColor.black)
-        zval = str(int(self.zValue()))
-        painter.drawText(QtCore.QPointF(center.x() - 4, center.y() + 4), zval)
-
-    def _styleSvg(self, element):
-        """
-        Add style from the shape item to the SVG element that we will
-        export
-        """
-        style = ""
-        pen = self.pen()
-        if hasattr(self, "brush"):  # Line don't have a brush
-            element.set("fill", "#{}".format(hex(self.brush().color().rgba())[4:]))
-            element.set("fill-opacity", str(self.brush().color().alphaF()))
-
-        dasharray = self.QT_DASH_TO_SVG[pen.style()]
-        if dasharray is None:  # No border to the element
-            return element
-        elif dasharray == "":
-            pass  # Solid line
-        else:
-            element.set("stroke-dasharray", dasharray)
-        element.set("stroke-width", str(pen.width()))
-        element.set("stroke", "#" + hex(pen.color().rgba())[4:])
-        return element
-
-    def _penFromSVGElement(self, svg):
-        """
-        Get a pen from a SVG element
-
-        :param svg:
-        """
-        pen = QtGui.QPen()
-        if svg.get("stroke-width"):
-            pen.setWidth(int(svg.get("stroke-width")))
-        if svg.get("stroke"):
-            pen.setColor(colorFromSvg(svg.get("stroke")))
-        # Map SVG stroke style (border of the element to the Qt version)
-        if not svg.get("stroke"):
-            pen.setStyle(QtCore.Qt.PenStyle.NoPen)
-        else:
-            pen.setStyle(QtCore.Qt.PenStyle.SolidLine)
-            stroke = svg.get("stroke-dasharray")
-            if stroke:
-                for (qt_stroke, svg_stroke) in self.QT_DASH_TO_SVG.items():
-                    if svg_stroke == stroke:
-                        pen.setStyle(qt_stroke)
-        return pen

gns3/items/ellipse_item.py

@@ -19,10 +19,7 @@
 Graphical representation of an ellipse on the QGraphicsScene.
 """
 
-import math
-import xml.etree.ElementTree as ET
-
-from ..qt import QtWidgets
+from ..qt import QtCore, QtGui, QtWidgets
 from .shape_item import ShapeItem
 
 
@@ -32,9 +29,25 @@ class EllipseItem(QtWidgets.QGraphicsEllipseItem, ShapeItem):
     Class to draw an ellipse on the scene.
     """
 
-    def __init__(self, width=200, height=200, **kws):
-        super().__init__(width=width, height=height, **kws)
+    def __init__(self, pos=None, width=200, height=200):
 
+        super().__init__()
+        self.setRect(0, 0, width, height)
+        pen = QtGui.QPen(QtCore.Qt.black, 2, QtCore.Qt.DashLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin)
+        self.setPen(pen)
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255, 255))  # default color is white and not transparent
+        self.setBrush(brush)
+        if pos:
+            self.setPos(pos)
+
+    def delete(self):
+        """
+        Deletes this ellipse.
+        """
+
+        self.scene().removeItem(self)
+        from ..topology import Topology
+        Topology.instance().removeEllipse(self)
 
     def paint(self, painter, option, widget=None):
         """
@@ -48,21 +61,16 @@ class EllipseItem(QtWidgets.QGraphicsEllipseItem, ShapeItem):
         super().paint(painter, option, widget)
         self.drawLayerInfo(painter)
 
-    def toSvg(self):
+    def duplicate(self):
         """
-        Return an SVG version of the shape
+        Duplicates this ellipse item.
+
+        :return: EllipseItem instance
         """
-        svg = ET.Element("svg")
-        svg.set("width", str(self.rect().width()))
-        svg.set("height", str(self.rect().height()))
-
-        ellipse = ET.SubElement(svg, "ellipse")
-        ellipse.set("cx", str(math.floor(self.rect().width() / 2)))
-        ellipse.set("rx", str(math.ceil(self.rect().width() / 2)))
-        ellipse.set("cy", str(math.floor(self.rect().height() / 2)))
-        ellipse.set("ry", str(math.ceil(self.rect().height() / 2)))
-
-        ellipse = self._styleSvg(ellipse)
-
-        return ET.tostring(svg, encoding="utf-8").decode("utf-8")
 
+        ellipse_item = EllipseItem(QtCore.QPointF(self.x() + 20, self.y() + 20), self.rect().width(), self.rect().height())
+        ellipse_item.setPen(self.pen())
+        ellipse_item.setBrush(self.brush())
+        ellipse_item.setZValue(self.zValue())
+        ellipse_item.setRotation(self.rotation())
+        return ellipse_item

gns3/items/ethernet_link_item.py

@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2019 Pekka Helenius
 # Copyright (C) 2014 GNS3 Technologies Inc.
 #
 # This program is free software: you can redistribute it and/or modify
@@ -22,7 +21,7 @@ Graphical representation of an Ethernet link for QGraphicsScene.
 
 from ..qt import QtCore, QtGui, QtWidgets
 from .link_item import LinkItem
-from .label_item import LabelItem
+from .note_item import NoteItem
 from ..ports.port import Port
 
 
@@ -37,11 +36,12 @@ class EthernetLinkItem(LinkItem):
     :param destination_port: destination Port instance
     :param link: Link instance (contains back-end stuff for this link)
     :param adding_flag: indicates if this link is being added (no destination yet)
+    :param multilink: used to draw multiple link between the same source and destination
     """
 
-    def __init__(self, source_item, source_port, destination_item, destination_port, link=None, adding_flag=False):
+    def __init__(self, source_item, source_port, destination_item, destination_port, link=None, adding_flag=False, multilink=0):
 
-        super().__init__(source_item, source_port, destination_item, destination_port, link, adding_flag)
+        super().__init__(source_item, source_port, destination_item, destination_port, link, adding_flag, multilink)
         self._source_collision_offset = 0.0
         self._destination_collision_offset = 0.0
 
@@ -52,16 +52,10 @@ class EthernetLinkItem(LinkItem):
 
         LinkItem.adjust(self)
 
-        try:
-            if self._hovered:
-                self.setPen(QtGui.QPen(QtCore.Qt.GlobalColor.red, self._link._link_style["width"] + 1, QtCore.Qt.PenStyle.SolidLine, QtCore.Qt.PenCapStyle.RoundCap, QtCore.Qt.PenJoinStyle.RoundJoin))
-            else:
-                self.setPen(QtGui.QPen(QtGui.QColor(self._link._link_style["color"]), self._link._link_style["width"], QtCore.Qt.PenStyle(self._link._link_style["type"]), QtCore.Qt.PenCapStyle.RoundCap, QtCore.Qt.PenJoinStyle.RoundJoin))
-        except:
-            if self._hovered:
-                self.setPen(QtGui.QPen(QtCore.Qt.GlobalColor.red, self._pen_width + 1, QtCore.Qt.PenStyle.SolidLine, QtCore.Qt.PenCapStyle.RoundCap, QtCore.Qt.PenJoinStyle.RoundJoin))
-            else:
-                self.setPen(QtGui.QPen(QtGui.QColor("#000000"), self._pen_width, QtCore.Qt.PenStyle.SolidLine, QtCore.Qt.PenCapStyle.RoundCap, QtCore.Qt.PenJoinStyle.RoundJoin))
+        if self._hovered:
+            self.setPen(QtGui.QPen(QtCore.Qt.red, self._pen_width + 1, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin))
+        else:
+            self.setPen(QtGui.QPen(QtCore.Qt.black, self._pen_width, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin))
 
         # draw a line between nodes
         path = QtGui.QPainterPath(self.source)
@@ -113,25 +107,22 @@ class EthernetLinkItem(LinkItem):
         """
 
         QtWidgets.QGraphicsPathItem.paint(self, painter, option, widget)
-        if not self._adding_flag:
+        if not self._adding_flag and self._settings["draw_link_status_points"]:
 
             # points disappears if nodes are too close to each others.
             if self.length < 100:
                 return
 
-            if self._link.suspended() or self._source_port.status() == Port.suspended:
-                # link or port is suspended
-                color = QtCore.Qt.GlobalColor.yellow
-                shape = QtCore.Qt.PenCapStyle.RoundCap
-            elif self._source_port.status() == Port.started:
+            if self._source_port.status() == Port.started:
                 # port is active
-                color = QtCore.Qt.GlobalColor.green
-                shape = QtCore.Qt.PenCapStyle.RoundCap
+                color = QtCore.Qt.green
+            elif self._source_port.status() == Port.suspended:
+                # port is suspended
+                color = QtCore.Qt.yellow
             else:
-                color = QtCore.Qt.GlobalColor.red
-                shape = QtCore.Qt.PenCapStyle.SquareCap
+                color = QtCore.Qt.red
 
-            painter.setPen(QtGui.QPen(color, self._point_size, QtCore.Qt.PenStyle.SolidLine, shape, QtCore.Qt.PenJoinStyle.MiterJoin))
+            painter.setPen(QtGui.QPen(color, self._point_size, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.MiterJoin))
             point1 = QtCore.QPointF(self.source + self.edge_offset) + QtCore.QPointF((self.dx * self._source_collision_offset) / self.length, (self.dy * self._source_collision_offset) / self.length)
 
             # avoid any collision of the status point with the source node
@@ -146,35 +137,36 @@ class EthernetLinkItem(LinkItem):
                     self._source_collision_offset -= 10
 
             source_port_label = self._source_port.label()
-
-            if source_port_label is None:
-                source_port_label = LabelItem(self._source_item)
-                source_port_label.setPlainText(self._source_port.shortName())
-                source_port_label.setPos(self.mapToItem(self._source_item, point1))
-                self._source_port.setLabel(source_port_label)
-
             if self._draw_port_labels:
-                source_port_label.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable, not self._source_item.locked())
-                source_port_label.show()
-            else:
+                if source_port_label is None:
+                    source_port_label = NoteItem(self._source_item)
+                    if not self._source_port.isStub():
+                        source_port_name = self._source_port.name().replace(self._source_port.longNameType(),
+                                                                            self._source_port.shortNameType())
+                    else:
+                        source_port_name = self._source_port.name()
+                    source_port_label.setPlainText(source_port_name)
+                    source_port_label.setPos(self.mapToItem(self._source_item, point1))
+                    self._source_port.setLabel(source_port_label)
+
+                elif source_port_label and not source_port_label.isVisible():
+                    source_port_label.show()
+
+            elif source_port_label:
                 source_port_label.hide()
 
-            if self._settings["draw_link_status_points"] and self.pen().style() != QtCore.Qt.PenStyle.NoPen:
-                painter.drawPoint(point1)
+            painter.drawPoint(point1)
 
-            if self._link.suspended() or self._destination_port.status() == Port.suspended:
-                # link or port is suspended
-                color = QtCore.Qt.GlobalColor.yellow
-                shape = QtCore.Qt.PenCapStyle.RoundCap
-            elif self._destination_port.status() == Port.started:
+            if self._destination_port.status() == Port.started:
                 # port is active
-                color = QtCore.Qt.GlobalColor.green
-                shape = QtCore.Qt.PenCapStyle.RoundCap
+                color = QtCore.Qt.green
+            elif self._destination_port.status() == Port.suspended:
+                # port is suspended
+                color = QtCore.Qt.yellow
             else:
-                color = QtCore.Qt.GlobalColor.red
-                shape = QtCore.Qt.PenCapStyle.SquareCap
+                color = QtCore.Qt.red
 
-            painter.setPen(QtGui.QPen(color, self._point_size, QtCore.Qt.PenStyle.SolidLine, shape, QtCore.Qt.PenJoinStyle.MiterJoin))
+            painter.setPen(QtGui.QPen(color, self._point_size, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.MiterJoin))
             point2 = QtCore.QPointF(self.destination - self.edge_offset) - QtCore.QPointF((self.dx * self._destination_collision_offset) / self.length, (self.dy * self._destination_collision_offset) / self.length)
 
             # avoid any collision of the status point with the destination node
@@ -189,20 +181,24 @@ class EthernetLinkItem(LinkItem):
                     self._destination_collision_offset -= 10
 
             destination_port_label = self._destination_port.label()
-
-            if destination_port_label is None:
-                destination_port_label = LabelItem(self._destination_item)
-                destination_port_label.setPlainText(self._destination_port.shortName())
-                destination_port_label.setPos(self.mapToItem(self._destination_item, point2))
-                self._destination_port.setLabel(destination_port_label)
-
             if self._draw_port_labels:
-                destination_port_label.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable, not self._destination_item.locked())
-                destination_port_label.show()
-            else:
+                if destination_port_label is None:
+                    destination_port_label = NoteItem(self._destination_item)
+                    if not self._destination_port.isStub():
+                        destination_port_name = self._destination_port.name().replace(self._destination_port.longNameType(),
+                                                                                      self._destination_port.shortNameType())
+                    else:
+                        destination_port_name = self._destination_port.name()
+                    destination_port_label.setPlainText(destination_port_name)
+                    destination_port_label.setPos(self.mapToItem(self._destination_item, point2))
+                    self._destination_port.setLabel(destination_port_label)
+
+                elif destination_port_label and not destination_port_label.isVisible():
+                    destination_port_label.show()
+
+            elif destination_port_label:
                 destination_port_label.hide()
 
-            if self._settings["draw_link_status_points"] and self.pen().style() != QtCore.Qt.PenStyle.NoPen:
-                painter.drawPoint(point2)
+            painter.drawPoint(point2)
 
-        self._drawSymbol()
+        self._drawCaptureSymbol()

gns3/items/image_item.py

@@ -19,41 +19,41 @@
 Graphical representation of an image on the QGraphicsScene.
 """
 
-from ..qt import QtSvgWidgets
-from ..qt.qimage_svg_renderer import QImageSvgRenderer
-from .drawing_item import DrawingItem
+from ..qt import QtWidgets, QtCore
 
 
-class ImageItem(QtSvgWidgets.QGraphicsSvgItem, DrawingItem):
+class ImageItem():
 
     """
     Class to insert an image on the scene.
     """
 
-    def __init__(self, image_path=None, pos=None, svg=None, **kws):
+    show_layer = False
 
+    def __init__(self, image_path, pos=None):
+
+        self.setFlags(self.ItemIsMovable | self.ItemIsSelectable)
         self._image_path = image_path
-        # Because we call the Qt C++ code we need to handle the case of pos is None otherwise we will get a conversion error
         if pos:
-            super().__init__(pos=pos, **kws)
-        else:
-            super().__init__(**kws)
+            self.setPos(pos)
 
-        if self._image_path:
-            renderer = QImageSvgRenderer(image_path)
-            self.setSharedRenderer(renderer)
+    def filePath(self):
+        """
+        Return image file
+        """
+        return self._image_path
 
-        # By default center the image
-        if pos is None:
-            x = self.pos().x() - (self.boundingRect().width() / 2)
-            y = self.pos().y() - (self.boundingRect().height() / 2)
-            self.setPos(x, y)
+    def delete(self):
+        """
+        Deletes this image item.
+        """
 
-        if svg:
-            svg = self.fromSvg(svg)
-
-        if 'z' in kws.keys():
-            self.setZValue(kws['z'])
+        self.scene().removeItem(self)
+        from ..topology import Topology
+        try:
+            Topology.instance().removeImage(self)
+        except OSError as e:
+            QtWidgets.QMessageBox.critical(self.parent(), "Image", "Cannot delete the image: {}".format(str(e)))
 
     def paint(self, painter, option, widget=None):
         """
@@ -65,14 +65,68 @@ class ImageItem(QtSvgWidgets.QGraphicsSvgItem, DrawingItem):
         """
 
         super().paint(painter, option, widget)
-        self.drawLayerInfo(painter)
 
-    def fromSvg(self, svg):
-        renderer = QImageSvgRenderer(svg)
-        self.setSharedRenderer(renderer)
+        if self.show_layer is False:
+            return
 
-    def toSvg(self):
+        brect = self.boundingRect()
+        # don't draw anything if the object is too small
+        if brect.width() < 20 or brect.height() < 20:
+            return
+
+        center = self.mapFromItem(self, brect.width() / 2.0, brect.height() / 2.0)
+        painter.setBrush(QtCore.Qt.red)
+        painter.setPen(QtCore.Qt.red)
+        painter.drawRect((brect.width() / 2.0) - 10, (brect.height() / 2.0) - 10, 20, 20)
+        painter.setPen(QtCore.Qt.black)
+        zval = str(int(self.zValue()))
+        painter.drawText(QtCore.QPointF(center.x() - 4, center.y() + 4), zval)
+
+    def setZValue(self, value):
         """
-        Return an SVG version of the shape
+        Sets a new Z value.
+
+        :param value: Z value
         """
-        return self.renderer().svg()
+
+        super().setZValue(value)
+        if self.zValue() < 0:
+            self.setFlag(self.ItemIsSelectable, False)
+            self.setFlag(self.ItemIsMovable, False)
+        else:
+            self.setFlag(self.ItemIsSelectable, True)
+            self.setFlag(self.ItemIsMovable, True)
+
+    def dump(self):
+        """
+        Returns a representation of this image item.
+
+        :returns: dictionary
+        """
+
+        image_info = {"path": self._image_path,
+                      "x": self.x(),
+                      "y": self.y()}
+
+        if self.zValue() != 0:
+            image_info["z"] = self.zValue()
+
+        return image_info
+
+    def load(self, image_info):
+        """
+        Loads an image representation
+        (from a topology file).
+
+        :param image_info: representation of the image item (dictionary)
+        """
+
+        # load mandatory properties
+        x = image_info["x"]
+        y = image_info["y"]
+        self.setPos(x, y)
+
+        # load optional properties
+        z = image_info.get("z")
+        if z is not None:
+            self.setZValue(z)

gns3/items/line_item.py

@@ -1,216 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2014 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/>.
-
-"""
-Graphical representation of a rectangle on the QGraphicsScene.
-"""
-
-import xml.etree.ElementTree as ET
-
-from ..qt import QtCore, QtGui, QtWidgets
-from .drawing_item import DrawingItem
-
-
-class LineItem(QtWidgets.QGraphicsLineItem, DrawingItem):
-
-    """
-    Class to draw a rectangle on the scene.
-    """
-
-    def __init__(self, dst=None, svg=None, **kws):
-        super().__init__(svg=svg, **kws)
-        self.setAcceptHoverEvents(True)
-
-        self._edge = None
-        self._border = 20
-
-        if svg is None:
-            if dst is not None:
-                self.setLine(0,
-                             0,
-                             dst.x(),
-                             dst.y())
-                pen = QtGui.QPen(QtCore.Qt.GlobalColor.black, 2, QtCore.Qt.PenStyle.SolidLine, QtCore.Qt.PenCapStyle.RoundCap, QtCore.Qt.PenJoinStyle.RoundJoin)
-                self.setPen(pen)
-        else:
-            self.fromSvg(svg)
-        if self._id is None:
-            self.create()
-
-    def paint(self, painter, option, widget=None):
-        """
-        Paints the contents of an item in local coordinates.
-
-        :param painter: QPainter instance
-        :param option: QStyleOptionGraphicsItem instance
-        :param widget: QWidget instance
-        """
-
-        super().paint(painter, option, widget)
-        self.drawLayerInfo(painter)
-
-    def toSvg(self):
-        """
-        Return an SVG version of the shape
-        """
-        svg = ET.Element("svg")
-        width = abs(self.line().x1() - self.line().x2())
-        height = abs(self.line().y1() - self.line().y2())
-        svg.set("width", str(int(width)))
-        svg.set("height", str(int(height)))
-
-        line = ET.SubElement(svg, "line")
-        line.set("x1", str(int(self.line().x1())))
-        line.set("x2", str(int(self.line().x2())))
-        line.set("y1", str(int(self.line().y1())))
-        line.set("y2", str(int(self.line().y2())))
-        line = self._styleSvg(line)
-
-        return ET.tostring(svg, encoding="utf-8").decode("utf-8")
-
-    def fromSvg(self, svg):
-        """
-        Import element informations from an SVG
-        """
-        svg = ET.fromstring(svg)
-        width = float(svg.get("width", 0))
-        height = float(svg.get("height", 0))
-
-        # Backup the pos and restore it
-        pos = self.pos()
-        y1 = self.line().y1()
-        self.setLine(0, 0, width, height)
-
-        pen = QtGui.QPen()
-
-        if len(svg):
-            pen = self._penFromSVGElement(svg[0])
-            self.setLine(
-                float(svg[0].get("x1")),
-                float(svg[0].get("y1")),
-                float(svg[0].get("x2")),
-                float(svg[0].get("y2"))
-            )
-        self.setPos(pos)
-        self.setPen(pen)
-        self.update()
-
-    def _isHorizontalLine(self):
-        return abs(self.line().x1() - self.line().x2()) > abs(self.line().y1() - self.line().y2())
-
-    def hoverMoveEvent(self, event):
-        """
-        Handles all hover move events.
-
-        :param event: QGraphicsSceneHoverEvent instance
-        """
-
-        # locked objects don't need cursors
-        if not self.locked():
-
-            if self._isHorizontalLine():
-                if event.pos().x() > (self.line().x2() - self._border):
-                    self._graphics_view.setCursor(QtCore.Qt.CursorShape.SizeHorCursor)
-                elif event.pos().x() < self._border:
-                    self._graphics_view.setCursor(QtCore.Qt.CursorShape.SizeHorCursor)
-                else:
-                    self._graphics_view.setCursor(QtCore.Qt.CursorShape.SizeAllCursor)
-            # Vertical line
-            else:
-                if event.pos().y() > (self.line().y2() - self._border):
-                    self._graphics_view.setCursor(QtCore.Qt.CursorShape.SizeVerCursor)
-                elif event.pos().y() < self._border:
-                    self._graphics_view.setCursor(QtCore.Qt.CursorShape.SizeVerCursor)
-                else:
-                    self._graphics_view.setCursor(QtCore.Qt.CursorShape.SizeAllCursor)
-
-    def mouseMoveEvent(self, event):
-        """
-        Handles all mouse move events.
-
-        :param event: QMouseEvent instance
-        """
-
-        self.update()
-        if self._edge:
-            scenePos = event.scenePos()
-            if self._edge == "left" or self._edge == "bottom":
-                diff_x = self.x() - scenePos.x()
-                diff_y = self.y() - scenePos.y()
-                self.setPos(scenePos.x(), scenePos.y())
-                self.setLine(
-                    0,
-                    0,
-                    self.line().x2() + diff_x,
-                    self.line().y2() + diff_y)
-            elif self._edge == "right" or self._edge == "top":
-                pos = self.mapFromScene(scenePos)
-                self.setLine(
-                    0,
-                    0,
-                    pos.x(),
-                    pos.y())
-                self.setPos(self.x(), self.y())
-        super().mouseMoveEvent(event)
-
-    def mousePressEvent(self, event):
-        """
-        Handles all mouse press events.
-
-        :param event: QMouseEvent instance
-        """
-
-        self.update()
-        if self._isHorizontalLine():
-            if event.pos().x() > (self.line().x2() - self._border):
-                self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable, False)
-                self._edge = "right"
-            elif event.pos().x() < (self.line().x1() + self._border):
-                self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable, False)
-                self._edge = "left"
-        else:
-            if event.pos().y() > (self.line().y2() - self._border):
-                self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable, False)
-                self._edge = "top"
-            elif event.pos().y() < (self.line().y1() + self._border):
-                self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable, False)
-                self._edge = "bottom"
-        super().mousePressEvent(event)
-
-    def mouseReleaseEvent(self, event):
-        """
-        Handles all mouse release events.
-
-        :param: QMouseEvent instance
-        """
-
-        self.update()
-        self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable)
-
-        self._edge = None
-        super().mouseReleaseEvent(event)
-
-    def hoverLeaveEvent(self, event):
-        """
-        Handles all hover leave events.
-
-        :param event: QGraphicsSceneHoverEvent instance
-        """
-
-        # locked objects don't need cursors
-        if not self.locked():
-            self._graphics_view.setCursor(QtCore.Qt.CursorShape.ArrowCursor)

gns3/items/link_item.py

@@ -21,24 +21,22 @@ Link items are graphical representation of a link on the QGraphicsScene
 """
 
 import math
-from ..qt import QtCore, QtGui, QtWidgets, QtSvgWidgets, qslot, sip_is_deleted
+import struct
+import sys
+from ..qt import QtCore, QtGui, QtWidgets, QtSvg
 
-from ..packet_capture import PacketCapture
-from ..dialogs.filter_dialog import FilterDialog
-from ..dialogs.style_editor_dialog_link import StyleEditorDialogLink
-from ..utils.get_icon import get_icon
+from ..node import Node
 
 
-class SvgIconItem(QtSvgWidgets.QGraphicsSvgItem):
+class SvgCaptureItem(QtSvg.QGraphicsSvgItem):
 
     def __init__(self, symbol, parent):
 
-        QtSvgWidgets.QGraphicsSvgItem.__init__(self, symbol, parent)
+        QtSvg.QGraphicsSvgItem.__init__(self, symbol, parent)
 
     def mousePressEvent(self, event):
 
-        if self.parentItem():
-            self.parentItem().mousePressEvent(event)
+        self.parentItem().mousePressEvent(event)
         event.accept()
 
 
@@ -53,16 +51,16 @@ class LinkItem(QtWidgets.QGraphicsPathItem):
     :param destination_port: destination Port instance
     :param link: Link instance (contains back-end stuff for this link)
     :param adding_flag: indicates if this link is being added (no destination yet)
+    :param multilink: used to draw multiple link between the same source and destination
     """
 
     _draw_port_labels = False
-    delete_link_item_signal = QtCore.Signal(str)
 
-    def __init__(self, source_item, source_port, destination_item, destination_port, link=None, adding_flag=False):
+    def __init__(self, source_item, source_port, destination_item, destination_port, link=None, adding_flag=False, multilink=0):
 
         super().__init__()
         self.setAcceptHoverEvents(True)
-        self.setZValue(-0.5)
+        self.setZValue(-1)
         self._link = None
 
         from ..main_window import MainWindow
@@ -79,6 +77,10 @@ class LinkItem(QtWidgets.QGraphicsPathItem):
         # default pen size
         self._pen_width = 2.0
 
+        # indicates the link position when there are multiple links
+        # between the same source and destination
+        self._multilink = multilink
+
         # source & destination items and ports
         self._source_item = source_item
         self._destination_item = destination_item
@@ -90,19 +92,11 @@ class LinkItem(QtWidgets.QGraphicsPathItem):
 
         # QGraphicsSvgItem to indicate a capture
         self._capturing_item = None
-        # QGraphicsSvgItem to indicate a filter is applied
-        self._filter_item = None
-        # QGraphicsSvgItem to indicate we suspend a link
-        self._suspend_item = None
-        # QGraphicsSvgItem to indicate a filter is applied and a capture is active
-        self._filter_capturing_item = None
 
         if not self._adding_flag:
             # there is a destination
             self._link = link
-            self._link.updated_link_signal.connect(self._drawSymbol)
-            self._link.delete_link_signal.connect(self._linkDeletedSlot)
-            self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsFocusable)
+            self.setFlag(self.ItemIsFocusable)
             source_item.addLink(self)
             destination_item.addLink(self)
             self.setCustomToolTip()
@@ -113,10 +107,20 @@ class LinkItem(QtWidgets.QGraphicsPathItem):
 
         self.adjust()
 
-    @qslot
-    def _linkDeletedSlot(self, link_id, *args):
-        # first delete the port labels if any
+    def delete(self):
+        """
+        Delete this link
+        """
 
+        if not self._source_port.isHotPluggable() and self._source_item.node().status() == Node.started:
+            self._source_item.node().stop()
+            QtWidgets.QMessageBox.critical(self._main_window, "Connection", "{} has been stopped because it doesn't support hot unlink.".format(self._source_item.node().name()))
+        if not self._destination_port.isHotPluggable() and self._destination_item.node().status() == Node.started:
+            self._destination_item.node().stop()
+            QtWidgets.QMessageBox.critical(self._main_window, "Connection", "{} has been stopped because it doesn't support hot unlink.".format(self._destination_item.node().name()))
+
+
+        # first delete the port labels if any
         if self._source_port.label():
             self._source_port.label().setParentItem(None)
             self.scene().removeItem(self._source_port.label())
@@ -124,40 +128,11 @@ class LinkItem(QtWidgets.QGraphicsPathItem):
             self._destination_port.label().setParentItem(None)
             self.scene().removeItem(self._destination_port.label())
 
-        if self.scene():
-            if self in self.scene().items():
-                self.scene().removeItem(self)
-
-    @qslot
-    def _filterActionSlot(self, *args):
-        dialog = FilterDialog(self._main_window, self._link)
-        dialog.show()
-        dialog.exec()
-
-    @qslot
-    def _suspendActionSlot(self, *args):
-        self._link.toggleSuspend()
-
-    @qslot
-    def _styleActionSlot(self, *args):
-        style_dialog = StyleEditorDialogLink(self, self._main_window)
-        style_dialog.show()
-        style_dialog.exec()
-
-    def setLinkStyle(self, link_style):
-        self._link._link_style["color"] = link_style["color"]
-        self._link._link_style["width"] = link_style["width"]
-        self._link._link_style["type"]  = link_style["type"]
-
-        # This refers to functions in link.py!
-        self._link.setLinkStyle(link_style)
-        self._link.update()
-
-    def delete(self):
-        """
-        Delete this link
-        """
+        self._source_item.removeLink(self)
+        self._destination_item.removeLink(self)
         self._link.deleteLink()
+        if self in self.scene().items():
+            self.scene().removeItem(self)
 
     def link(self):
         """
@@ -237,64 +212,39 @@ class LinkItem(QtWidgets.QGraphicsPathItem):
         :param menu: QMenu instance
         """
 
-        if not self._link.capturing():
+        if not self._source_port.capturing() or not self._destination_port.capturing():
             # start capture
-            start_capture_action = QtGui.QAction("Start capture", menu)
-            start_capture_action.setIcon(get_icon('capture-start.svg'))
+            start_capture_action = QtWidgets.QAction("Start capture", menu)
+            start_capture_action.setIcon(QtGui.QIcon(':/icons/capture-start.svg'))
             start_capture_action.triggered.connect(self._startCaptureActionSlot)
             menu.addAction(start_capture_action)
 
-        if self._link.capturing():
+        if self._source_port.capturing() or self._destination_port.capturing():
             # stop capture
-            stop_capture_action = QtGui.QAction("Stop capture", menu)
-            stop_capture_action.setIcon(get_icon('capture-stop.svg'))
+            stop_capture_action = QtWidgets.QAction("Stop capture", menu)
+            stop_capture_action.setIcon(QtGui.QIcon(':/icons/capture-stop.svg'))
             stop_capture_action.triggered.connect(self._stopCaptureActionSlot)
             menu.addAction(stop_capture_action)
 
             # start wireshark
-            start_wireshark_action = QtGui.QAction("Start Wireshark", menu)
+            start_wireshark_action = QtWidgets.QAction("Start Wireshark", menu)
             start_wireshark_action.setIcon(QtGui.QIcon(":/icons/wireshark.png"))
             start_wireshark_action.triggered.connect(self._startWiresharkActionSlot)
             menu.addAction(start_wireshark_action)
 
-            if PacketCapture.instance().packetAnalyzerAvailable():
-                analyze_action = QtGui.QAction("Analyze capture", menu)
+            if sys.platform.startswith("win") and struct.calcsize("P") * 8 == 64:
+                # Windows 64-bit only (Solarwinds RTV limitation).
+                analyze_action = QtWidgets.QAction("Analyze capture", menu)
                 analyze_action.setIcon(QtGui.QIcon(':/icons/rtv.png'))
                 analyze_action.triggered.connect(self._analyzeCaptureActionSlot)
                 menu.addAction(analyze_action)
 
-        if self._link.suspended() is False:
-            # Edit filters
-            filter_action = QtGui.QAction("Packet filters", menu)
-            filter_action.setIcon(get_icon('filter.svg'))
-            filter_action.triggered.connect(self._filterActionSlot)
-            menu.addAction(filter_action)
-
-            # Suspend link
-            suspend_action = QtGui.QAction("Suspend", menu)
-            suspend_action.setIcon(get_icon('pause.svg'))
-            suspend_action.triggered.connect(self._suspendActionSlot)
-            menu.addAction(suspend_action)
-        else:
-            # Resume link
-            resume_action = QtGui.QAction("Resume", menu)
-            resume_action.setIcon(get_icon('start.svg'))
-            resume_action.triggered.connect(self._suspendActionSlot)
-            menu.addAction(resume_action)
-
-        # style
-        style_action = QtGui.QAction("Style", menu)
-        style_action.setIcon(get_icon("node_conception.svg"))
-        style_action.triggered.connect(self._styleActionSlot)
-        menu.addAction(style_action)
-
         # delete
-        delete_action = QtGui.QAction("Delete", menu)
-        delete_action.setIcon(get_icon('delete.svg'))
+        delete_action = QtWidgets.QAction("Delete", menu)
+        delete_action.setIcon(QtGui.QIcon(':/icons/delete.svg'))
         delete_action.triggered.connect(self._deleteActionSlot)
         menu.addAction(delete_action)
 
-    @qslot
     def mousePressEvent(self, event):
         """
         Called when the link is clicked and shows a contextual menu.
@@ -302,31 +252,22 @@ class LinkItem(QtWidgets.QGraphicsPathItem):
         :param: QGraphicsSceneMouseEvent instance
         """
 
-        if event.button() == QtCore.Qt.MouseButton.RightButton and self._adding_flag:
-            # send a escape key to the main window to cancel the link addition
-            from ..main_window import MainWindow
-            key = QtGui.QKeyEvent(QtCore.QEvent.Type.KeyPress, QtCore.Qt.Key.Key_Escape, QtCore.Qt.KeyboardModifier.NoModifier)
-            QtWidgets.QApplication.sendEvent(MainWindow.instance(), key)
-            return
-        else:
-            super().mousePressEvent(event)
+        if event.button() == QtCore.Qt.RightButton:
+            if self._adding_flag:
+                # send a escape key to the main window to cancel the link addition
+                from ..main_window import MainWindow
+                key = QtGui.QKeyEvent(QtCore.QEvent.KeyPress, QtCore.Qt.Key_Escape, QtCore.Qt.NoModifier)
+                QtWidgets.QApplication.sendEvent(MainWindow.instance(), key)
+                return
 
-    def contextMenuEvent(self, event):
-        """
-        Handles all context menu events.
-
-        :param event: QContextMenuEvent instance
-        """
-
-        if not sip_is_deleted(self):
             # create the contextual menu
-            self.setHovered(True)
             self.setAcceptHoverEvents(False)
-            menu = QtWidgets.QMenu(parent=self.scene().parent())
+            menu = QtWidgets.QMenu()
             self.populateLinkContextualMenu(menu)
-            menu.exec(QtGui.QCursor.pos())
+            menu.exec_(QtGui.QCursor.pos())
             self.setAcceptHoverEvents(True)
-            self.setHovered(False)
+            self._hovered = False
+            self.adjust()
 
     def keyPressEvent(self, event):
         """
@@ -336,7 +277,7 @@ class LinkItem(QtWidgets.QGraphicsPathItem):
         """
 
         # On pressing backspace or delete key, the selected link gets deleted
-        if event.key() == QtCore.Qt.Key.Key_Delete or event.key() == QtCore.Qt.Key.Key_Backspace:
+        if event.key() == QtCore.Qt.Key_Delete or event.key() == QtCore.Qt.Key_Backspace:
             self._deleteActionSlot()
             return
 
@@ -354,7 +295,26 @@ class LinkItem(QtWidgets.QGraphicsPathItem):
         contextual menu.
         """
 
-        PacketCapture.instance().startCapture(self._link)
+        ports = {}
+        if self._source_port.packetCaptureSupported() and not self._source_port.capturing():
+            for dlt_name, dlt in self._source_port.dataLinkTypes().items():
+                port = "{} port {} ({} encapsulation: {})".format(self._source_item.node().name(), self._source_port.name(), dlt_name, dlt)
+                ports[port] = [self._source_item.node(), self._source_port, dlt]
+
+        if self._destination_port.packetCaptureSupported() and not self._destination_port.capturing():
+            for dlt_name, dlt in self._destination_port.dataLinkTypes().items():
+                port = "{} port {} ({} encapsulation: {})".format(self._destination_item.node().name(), self._destination_port.name(), dlt_name, dlt)
+                ports[port] = [self._destination_item.node(), self._destination_port, dlt]
+
+        if not ports:
+            QtWidgets.QMessageBox.critical(self._main_window, "Packet capture", "Packet capture is not supported on this link")
+            return
+
+        selection, ok = QtWidgets.QInputDialog.getItem(self._main_window, "Packet capture", "Please select a port:", list(ports.keys()), 0, False)
+        if ok:
+            if selection in ports:
+                node, port, dlt = ports[selection]
+                node.startPacketCapture(port, port.captureFileName(node.name()), dlt)
 
     def _stopCaptureActionSlot(self):
         """
@@ -362,7 +322,21 @@ class LinkItem(QtWidgets.QGraphicsPathItem):
         contextual menu.
         """
 
-        PacketCapture.instance().stopCapture(self._link)
+        if self._source_port.capturing() and self._destination_port.capturing():
+            ports = {}
+            source_port = "{} port {}".format(self._source_item.node().name(), self._source_port.name())
+            ports[source_port] = [self._source_item.node(), self._source_port]
+            destination_port = "{} port {}".format(self._destination_item.node().name(), self._destination_port.name())
+            ports[destination_port] = [self._destination_item.node(), self._destination_port]
+            selection, ok = QtWidgets.QInputDialog.getItem(self._main_window, "Packet capture", "Please select a port:", list(ports.keys()), 0, False)
+            if ok:
+                if selection in ports:
+                    node, port = ports[selection]
+                    node.stopPacketCapture(port)
+        elif self._source_port.capturing():
+            self._source_item.node().stopPacketCapture(self._source_port)
+        elif self._destination_port.capturing():
+            self._destination_item.node().stopPacketCapture(self._destination_port)
 
     def _startWiresharkActionSlot(self):
         """
@@ -370,7 +344,22 @@ class LinkItem(QtWidgets.QGraphicsPathItem):
         contextual menu.
         """
 
-        PacketCapture.instance().startPacketCaptureReader(self._link)
+        try:
+            if self._source_port.capturing() and self._destination_port.capturing():
+                ports = ["{} port {}".format(self._source_item.node().name(), self._source_port.name()),
+                         "{} port {}".format(self._destination_item.node().name(), self._destination_port.name())]
+                selection, ok = QtWidgets.QInputDialog.getItem(self._main_window, "Packet capture", "Please select a port:", ports, 0, False)
+                if ok:
+                    if selection.endswith(self._source_port.name()):
+                        self._source_port.startPacketCaptureReader(self._source_item.node().name())
+                    else:
+                        self._destination_port.startPacketCaptureReader(self._destination_item.node().name())
+            elif self._source_port.capturing():
+                self._source_port.startPacketCaptureReader(self._source_item.node().name())
+            elif self._destination_port.capturing():
+                self._destination_port.startPacketCaptureReader(self._destination_item.node().name())
+        except OSError as e:
+            QtWidgets.QMessageBox.critical(self._main_window, "Packet capture", "Cannot start Wireshark: {}".format(e))
 
     def _analyzeCaptureActionSlot(self):
         """
@@ -379,7 +368,19 @@ class LinkItem(QtWidgets.QGraphicsPathItem):
         """
 
         try:
-            PacketCapture.instance().startPacketCaptureAnalyzer(self._link)
+            if self._source_port.capturing() and self._destination_port.capturing():
+                ports = ["{} port {}".format(self._source_item.node().name(), self._source_port.name()),
+                         "{} port {}".format(self._destination_item.node().name(), self._destination_port.name())]
+                selection, ok = QtWidgets.QInputDialog.getItem(self._main_window, "Capture analyzer", "Please select a port:", ports, 0, False)
+                if ok:
+                    if selection.endswith(self._source_port.name()):
+                        self._source_port.startPacketCaptureAnalyzer()
+                    else:
+                        self._destination_port.startPacketCaptureAnalyzer()
+            elif self._source_port.capturing():
+                self._source_port.startPacketCaptureAnalyzer()
+            elif self._destination_port.capturing():
+                self._destination_port.startPacketCaptureAnalyzer()
         except OSError as e:
             QtWidgets.QMessageBox.critical(self._main_window, "Capture analyzer", "Cannot start the packet capture analyzer program: {}".format(e))
 
@@ -414,7 +415,6 @@ class LinkItem(QtWidgets.QGraphicsPathItem):
 
         self.setHovered(False)
 
-    @qslot
     def adjust(self):
         """
         Computes the source point and destination point.
@@ -424,7 +424,7 @@ class LinkItem(QtWidgets.QGraphicsPathItem):
         # links must always be below node items on the scene
         if not self._adding_flag:
             min_zvalue = min([self._source_item.zValue(), self._destination_item.zValue()])
-            self.setZValue(min_zvalue - 0.5)
+            self.setZValue(min_zvalue - 1)
 
         self.prepareGeometryChange()
         source_rect = self._source_item.boundingRect()
@@ -442,54 +442,15 @@ class LinkItem(QtWidgets.QGraphicsPathItem):
         # compute the length of the line
         self.length = math.sqrt(self.dx * self.dx + self.dy * self.dy)
 
-        multilink = self._computeMultiLink()
-
         # multi-link management
-        if not self._adding_flag and multilink and self.length:
+        if not self._adding_flag and self._multilink and self.length:
             angle = math.radians(90)
             self.dxrot = math.cos(angle) * self.dx - math.sin(angle) * self.dy
             self.dyrot = math.sin(angle) * self.dx + math.cos(angle) * self.dy
-            offset = QtCore.QPointF((self.dxrot * (multilink * 5)) / self.length, (self.dyrot * (multilink * 5)) / self.length)
+            offset = QtCore.QPointF((self.dxrot * (self._multilink * 5)) / self.length, (self.dyrot * (self._multilink * 5)) / self.length)
             self.source = QtCore.QPointF(self.source + offset)
             self.destination = QtCore.QPointF(self.destination + offset)
 
-    def _computeMultiLink(self):
-        # Multi-link management
-        #
-        # multi is the offset of the link
-        # +------+       multi = -1    Link 2  +-------+
-        # |      +-----------------------------+       |
-        # |  R1  |                             |   R2  |
-        # |      |        multi = 0    Link 1  |       |
-        # |      +-----------------------------+       |
-        # |      |        multi = 1    Link 3  |       |
-        # +------+-----------------------------+-------+
-
-        if self._source_item == self._destination_item:
-            multi = 0
-        elif not hasattr(self._destination_item, "node"):  # Could be temporary a qpointf during link creation
-            multi = 0
-        else:
-            multi = 0
-            link_items = self._source_item.links()
-            for link_item in link_items:
-                if link_item == self:
-                    break
-                if link_item.destinationItem().node().id() == self._destination_item.node().id():
-                    multi += 1
-                if link_item.sourceItem().node().id() == self._destination_item.node().id():
-                    multi += 1
-
-        # MAX 7 links on the scene between 2 nodes
-        if multi > 7:
-            multi = 0
-        # Pair item represent the bottom links
-        elif multi % 2 == 0:
-            multi = multi // 2
-        else:
-            multi = -multi // 2
-        return multi
-
     def setMousePoint(self, scene_point):
         """
         Sets new mouse point coordinates.
@@ -502,91 +463,19 @@ class LinkItem(QtWidgets.QGraphicsPathItem):
         self.adjust()
         self.update()
 
-    @qslot
-    def _drawSymbol(self, *args):
+    def _drawCaptureSymbol(self):
         """
-        Draws a symbol in the middle of the link to indicate a capture, a suspend or a filter is active.
+        Draws a capture symbol in the middle of the link to indicate a capture is active.
         """
 
-        #FIXME: refactor ugly symbol management
         if not self._adding_flag:
-
-            if self._link.suspended():
-                if self.length >= 150:
-                    link_center = QtCore.QPointF(self.source.x() + self.dx / 2.0 - 11, self.source.y() + self.dy / 2.0 - 11)
-                    if self._suspend_item is None:
-                        self._suspend_item = SvgIconItem(':/icons/pause.svg', self)
-                        self._suspend_item.setScale(0.6)
-                    if not self._suspend_item.isVisible():
-                        self._suspend_item.show()
-                    self._suspend_item.setPos(link_center)
-                    if self._filter_item:
-                        self._filter_item.hide()
-                elif self._suspend_item:
-                    self._suspend_item.hide()
-                if self._filter_capturing_item:
-                    self._filter_capturing_item.hide()
-                if self._capturing_item:
-                    self._capturing_item.hide()
-                if self._filter_item:
-                    self._filter_item.hide()
-
-            elif self._link.capturing() and len(self._link.filters()) > 0:
-                if self.length >= 150:
-                    link_center = QtCore.QPointF(self.source.x() + self.dx / 2.0 - 11, self.source.y() + self.dy / 2.0 - 11)
-                    if self._filter_capturing_item is None:
-                        self._filter_capturing_item = SvgIconItem(':/icons/filter-capture.svg', self)
-                        self._filter_capturing_item.setScale(0.6)
-                    if not self._filter_capturing_item.isVisible():
-                        self._filter_capturing_item.show()
-                    self._filter_capturing_item.setPos(link_center)
-                elif self._filter_capturing_item:
-                    self._filter_capturing_item.hide()
-                if self._capturing_item:
-                    self._capturing_item.hide()
-                if self._filter_item:
-                    self._filter_item.hide()
-                if self._suspend_item:
-                    self._suspend_item.hide()
-
-            elif self._link.capturing():
-                if self.length >= 150:
-                    link_center = QtCore.QPointF(self.source.x() + self.dx / 2.0 - 11, self.source.y() + self.dy / 2.0 - 11)
-                    if self._capturing_item is None:
-                        self._capturing_item = SvgIconItem(':/icons/inspect.svg', self)
-                        self._capturing_item.setScale(0.6)
-                    self._capturing_item.setPos(link_center)
-                    if not self._capturing_item.isVisible():
-                        self._capturing_item.show()
-                elif self._capturing_item:
-                    self._capturing_item.hide()
-                if self._filter_capturing_item:
-                    self._filter_capturing_item.hide()
-                if self._suspend_item:
-                    self._suspend_item.hide()
-
-            elif len(self._link.filters()) > 0:
-                if self.length >= 150:
-                    link_center = QtCore.QPointF(self.source.x() + self.dx / 2.0 - 11, self.source.y() + self.dy / 2.0 - 11)
-                    if self._filter_item is None:
-                        self._filter_item = SvgIconItem(':/icons/filter.svg', self)
-                        self._filter_item.setScale(0.6)
-                    if not self._filter_item.isVisible():
-                        self._filter_item.show()
-                    self._filter_item.setPos(link_center)
-                elif self._filter_item:
-                    self._filter_item.hide()
-                if self._filter_capturing_item:
-                    self._filter_capturing_item.hide()
-                if self._suspend_item:
-                    self._suspend_item.hide()
-
-            else:
-                if self._capturing_item:
-                    self._capturing_item.hide()
-                if self._suspend_item:
-                    self._suspend_item.hide()
-                if self._filter_item:
-                    self._filter_item.hide()
-                if self._filter_capturing_item:
-                    self._filter_capturing_item.hide()
+            if (self._source_port.capturing() or self._destination_port.capturing()) and self.length >= 150:
+                link_center = QtCore.QPointF(self.source.x() + self.dx / 2.0 - 11, self.source.y() + self.dy / 2.0 - 11)
+                if self._capturing_item is None:
+                    self._capturing_item = SvgCaptureItem(':/icons/inspect.svg', self)
+                    self._capturing_item.setScale(0.6)
+                self._capturing_item.setPos(link_center)
+                if not self._capturing_item.isVisible():
+                    self._capturing_item.show()
+            elif self._capturing_item:
+                self._capturing_item.hide()

gns3/items/logo_item.py

@@ -1,136 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2018 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 urllib.parse
-
-from ..qt import QtCore, QtGui, QtWidgets, QtSvgWidgets
-from ..qt.qimage_svg_renderer import QImageSvgRenderer
-from ..controller import Controller
-
-
-import logging
-log = logging.getLogger(__name__)
-
-
-class LogoItem(QtSvgWidgets.QGraphicsSvgItem):
-    """
-    Margin for the logo
-    """
-    MARGIN = 20
-
-    """
-    Logo for the scene.
-
-    :param logo_path: Path to the logo (remote)
-    :param logo_url: URL which needs to be open user clicks on the logo
-    :param project: Current project
-    """
-
-    def __init__(self, logo_path, logo_url, project):
-        super().__init__()
-
-        self._logo_path = logo_path
-        self._logo_url = logo_url
-        self._project = project
-
-        # Temporary symbol during loading
-        renderer = QImageSvgRenderer(":/icons/reload.svg")
-        renderer.setObjectName("symbol_loading")
-        self.setSharedRenderer(renderer)
-
-        effect = QtWidgets.QGraphicsColorizeEffect()
-        effect.setColor(QtGui.QColor("black"))
-        effect.setStrength(0.8)
-        self.setGraphicsEffect(effect)
-        self.graphicsEffect().setEnabled(False)
-
-        # set graphical settings for this item
-        self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsFocusable)
-        self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemSendsGeometryChanges)
-        self.setAcceptHoverEvents(True)
-
-        from ..main_window import MainWindow
-        self._main_window = MainWindow.instance()
-        self._settings = self._main_window.uiGraphicsView.settings()
-
-        self.updatePosition()
-
-        self._main_window.uiGraphicsView.viewport().installEventFilter(self)
-
-        remote_file = urllib.parse.quote('project-files/images/{}'.format(logo_path))
-
-        Controller.instance().getStatic(
-            '/projects/{}/files/{}'.format(project.id(), remote_file),
-            self.updateImage
-        )
-
-        # make it the last one
-        self.setZValue(-2)
-
-    def eventFilter(self, source, event):
-        if event.type() == QtCore.QEvent.Type.Paint:
-            self.updatePosition()
-        return QtWidgets.QWidget.eventFilter(self, source, event)
-
-
-    def updateImage(self, local_path):
-        renderer = QImageSvgRenderer(local_path)
-        renderer.setObjectName("project_logo")
-        self.setSharedRenderer(renderer)
-
-
-    def updatePosition(self):
-        """
-        Updates position to be located in the right bottom corner
-        """
-        logo_rect = self.boundingRect()
-        width = self._main_window.uiGraphicsView.viewport().width()
-        height = self._main_window.uiGraphicsView.viewport().height()
-        rect = self._main_window.uiGraphicsView.mapToScene(QtCore.QRect(0, 0, width, height)).boundingRect()
-        x = rect.x() + rect.width() - self.MARGIN - logo_rect.width()
-        y = rect.y() + rect.height() - self.MARGIN - logo_rect.height()
-
-        # update only when changes
-        if [int(self.x()), int(self.y())] != [int(x), int(y)]:
-            self.setX(x)
-            self.setY(y)
-            self.update()
-
-    def hoverEnterEvent(self, event):
-        """
-        Handles all hover enter events for this item.
-
-        :param event: QGraphicsSceneHoverEvent instance
-        """
-
-        if self._logo_url is not None:
-            self.graphicsEffect().setEnabled(True)
-
-    def hoverLeaveEvent(self, event):
-        """
-        Handles all hover leave events for this item.
-
-        :param event: QGraphicsSceneHoverEvent instance
-        """
-
-        self.graphicsEffect().setEnabled(False)
-
-    def mousePressEvent(self, event):
-        url = QtCore.QUrl(self._logo_url)
-        if not QtGui.QDesktopServices.openUrl(url):
-            QtWidgets.QMessageBox.warning(self, 'Open Url', 'Could not open url')

gns3/items/node_item.py

@@ -19,20 +19,14 @@
 Graphical representation of a node on the QGraphicsScene.
 """
 
-from ..qt import sip
-
-from ..qt import QtCore, QtGui, QtWidgets, QtSvgWidgets, qslot
-from ..qt.qimage_svg_renderer import QImageSvgRenderer
-from .label_item import LabelItem
-from ..symbol import Symbol
-from ..controller import Controller
-
+from ..qt import QtCore, QtGui, QtWidgets
+from .note_item import NoteItem
 
 import logging
 log = logging.getLogger(__name__)
 
 
-class NodeItem(QtSvgWidgets.QGraphicsSvgItem):
+class NodeItem():
 
     """
     Node for the scene.
@@ -43,46 +37,33 @@ class NodeItem(QtSvgWidgets.QGraphicsSvgItem):
     show_layer = False
 
     def __init__(self, node):
-        super().__init__()
 
         # attached node
         self._node = node
-        # link items connected to this node item.
-        self._links = []
-        self._symbol = None
-        self._locked = False
-        self._allow_snap_to_grid = True
-
-        # says if the attached node has been initialized
-        # by the server.
-        self._initialized = False
 
         # node label
         self._node_label = None
 
-        self.setPos(QtCore.QPointF(self._node.x(), self._node.y()))
-
-        # Temporary symbol during loading
-        renderer = QImageSvgRenderer(":/icons/reload.svg")
-        renderer.setObjectName("symbol_loading")
-        self.setSharedRenderer(renderer)
+        # link items connected to this node item.
+        self._links = []
 
         effect = QtWidgets.QGraphicsColorizeEffect()
         effect.setColor(QtGui.QColor("black"))
         effect.setStrength(0.8)
+        #effect = QtWidgets.QGraphicsDropShadowEffect()
+        # effect.setColor(QtGui.QColor("darkGray"))
+        # effect.setBlurRadius(0)
+        #effect.setOffset(3, 3)
         self.setGraphicsEffect(effect)
         self.graphicsEffect().setEnabled(False)
 
         # set graphical settings for this node
-        self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable)
-        self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsSelectable)
-        self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsFocusable)
-        self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemSendsGeometryChanges)
+        self.setFlag(QtWidgets.QGraphicsItem.ItemIsMovable)
+        self.setFlag(QtWidgets.QGraphicsItem.ItemIsSelectable)
+        self.setFlag(QtWidgets.QGraphicsItem.ItemIsFocusable)
+        self.setFlag(QtWidgets.QGraphicsItem.ItemSendsGeometryChanges)
         self.setAcceptHoverEvents(True)
-
-        # update z value and locked state
-        self.setLocked(self._node.locked())
-        self.setZValue(self._node.z())
+        self.setZValue(1)
 
         # connect signals to know about some events
         # e.g. when the node has been started, stopped or suspended etc.
@@ -92,12 +73,17 @@ class NodeItem(QtSvgWidgets.QGraphicsSvgItem):
         node.suspended_signal.connect(self.suspendedSlot)
         node.updated_signal.connect(self.updatedSlot)
         node.deleted_signal.connect(self.deletedSlot)
+        node.delete_links_signal.connect(self.deleteLinksSlot)
         node.error_signal.connect(self.errorSlot)
         node.server_error_signal.connect(self.serverErrorSlot)
 
         # used when a port has been selected from the contextual menu
         self._selected_port = None
 
+        # says if the attached node has been initialized
+        # by the server.
+        self._initialized = False
+
         # contains the last error message received
         # from the server.
         self._last_error = None
@@ -106,56 +92,14 @@ class NodeItem(QtSvgWidgets.QGraphicsSvgItem):
         self._main_window = MainWindow.instance()
         self._settings = self._main_window.uiGraphicsView.settings()
 
-        if node.initialized():
-            self.createdSlot(node.id())
-
-        if self._main_window.uiSnapToGridAction.isChecked():
-            self.setPos(QtCore.QPointF(self._node.x() + 0.1, self._node.y()))
-
-    def updateNode(self):
+    def setUnsavedState(self):
         """
-        Sync change to the node
+        Indicates the project is in a unsaved state.
         """
 
-        self._node.setGraphics(self)
-
-    @qslot
-    def setSymbol(self, symbol):
-        """
-        :param symbol: Change the symbol path
-        """
-        # create renderer using symbols path/resource
-        if symbol is None:
-            symbol = self._node.defaultSymbol()
-        if self._symbol != symbol:
-            self._symbol = symbol
-
-            # Temporary symbol during loading
-            renderer = QImageSvgRenderer(":/icons/reload.svg")
-            renderer.setObjectName("symbol_loading")
-            self.setSharedRenderer(renderer)
-
-            Controller.instance().getStatic(Symbol(symbol_id=symbol).url(), self._symbolLoadedCallback)
-
-    def symbol(self):
-        return self._symbol
-
-    @qslot
-    def _symbolLoadedCallback(self, path, *args):
-
-        renderer = QImageSvgRenderer(path, fallback=":/icons/cancel.svg")
-        renderer.setObjectName(path)
-        self.setSharedRenderer(renderer)
-        if self._settings["limit_size_node_symbols"] is True and renderer.defaultSize().height() > 80:
-            # resize the SVG
-            renderer.resize(80)
-            self.setSharedRenderer(renderer)
-        if self._node.settings().get("symbol") != self._symbol:
-            self.updateNode()
-        if not self._initialized:
-            self._showLabel()
-            self._initialized = True
-            self.updateNode()
+        from ..main_window import MainWindow
+        main_window = MainWindow.instance()
+        main_window.setUnsavedState()
 
     def node(self):
         """
@@ -166,44 +110,27 @@ class NodeItem(QtSvgWidgets.QGraphicsSvgItem):
 
         return self._node
 
-    def setPos(self, *args):
-        super().setPos(*args)
-        self._node.setSettingValue("x", int(self.x()))
-        self._node.setSettingValue("y", int(self.y()))
-
-    @qslot
-    def addLink(self, link_item, *args):
+    def addLink(self, link):
         """
         Adds a link items to this node item.
 
         :param link: LinkItem instance
         """
 
-        if not sip.isdeleted(link_item):
-            self._links.append(link_item)
-            link_item.link().delete_link_signal.connect(self._removeLink)
-            link_item.link().updated_link_signal.connect(self._linkUpdatedSlot)
-            self._node.updated_signal.emit()
-
-    @qslot
-    def _linkUpdatedSlot(self, *args):
-        """
-        When a link change we also notify the listener of the node
-        """
+        self._links.append(link)
         self._node.updated_signal.emit()
+        self.setUnsavedState()
 
-    @qslot
-    def _removeLink(self, link_id, *args):
+    def removeLink(self, link):
         """
         Removes a link items from this node item.
 
         :param link: LinkItem instance
         """
 
-        for link_item in self._links:
-            if link_item.link().id() == link_id:
-                self._links.remove(link_item)
-                return
+        if link in self._links:
+            self._links.remove(link)
+        self.setUnsavedState()
 
     def links(self):
         """
@@ -214,102 +141,119 @@ class NodeItem(QtSvgWidgets.QGraphicsSvgItem):
 
         return self._links
 
-    @qslot
-    def createdSlot(self, base_node_id, *args):
+    def createdSlot(self, node_id):
         """
         Slot to receive events from the attached Node instance
         when a the node has been created/initialized.
 
-        :param base_node_id: base node identifier (integer)
+        :param node_id: node identifier (integer)
         """
 
-        self.setPos(QtCore.QPointF(self._node.x(), self._node.y()))
-        self.setSymbol(self._node.symbol())
+        if self is None:
+            return
+        self._initialized = True
         self.update()
+        self._showLabel()
 
-    @qslot
-    def startedSlot(self, *args):
+    def startedSlot(self):
         """
         Slot to receive events from the attached Node instance
         when a the node has started.
         """
 
+        if self is None:
+            return
         for link in self._links:
             link.update()
 
-    @qslot
-    def stoppedSlot(self, *args):
+    def stoppedSlot(self):
         """
         Slot to receive events from the attached Node instance
         when a the node has stopped.
         """
 
+        if self is None:
+            return
         for link in self._links:
             link.update()
 
-    @qslot
-    def suspendedSlot(self, *args):
+    def suspendedSlot(self):
         """
         Slot to receive events from the attached Node instance
         when a the node has suspended.
         """
 
+        if self is None:
+            return
         for link in self._links:
             link.update()
 
-    @qslot
-    def updatedSlot(self, *args):
+    def updatedSlot(self):
         """
         Slot to receive events from the attached Node instance
         when a the node has been updated.
         """
 
-        self.setSymbol(self._node.settings().get("symbol"))
-        self.setPos(self._node.settings().get("x", 0), self._node.settings().get("y", 0))
-        self.setZValue(self._node.settings().get("z", 0))
-        self.setLocked(self._node.settings().get("locked", False))
-        self._updateLabel()
+        if self is None:
+            return
+        if self._node_label:
+            if self._node_label.toPlainText() != self._node.name():
+                self._node_label.setPlainText(self._node.name())
+                self._centerLabel()
+        self.setUnsavedState()
 
         # update the link tooltips in case the
         # node name has changed
         for link in self._links:
             link.setCustomToolTip()
 
-    @qslot
-    def deletedSlot(self, *args):
+    def deleteLinksSlot(self):
+        """
+        Slot to receive events from the attached Node instance
+        when a all the links must be deleted.
+        """
+
+        if self is None:
+            return
+        for link in self._links.copy():
+            link.delete()
+
+    def deletedSlot(self):
         """
         Slot to receive events from the attached Node instance
         when the node has been deleted.
         """
 
-        if not self.scene():
+        if self is None:
             return
+        self._node.removeAllocatedName()
         if self in self.scene().items():
             self.scene().removeItem(self)
+        self.setUnsavedState()
 
-    @qslot
-    def serverErrorSlot(self, base_node_id, message, *args):
+    def serverErrorSlot(self, node_id, message):
         """
         Slot to receive events from the attached Node instance
         when the node has received an error from the server.
 
-        :param base_node_id: base node identifier
+        :param node_id: node identifier
         :param message: error message
         """
 
-        self._last_error = "{message}".format(message=message)
+        if self:
+            self._last_error = "{message}".format(message=message)
 
-    @qslot
-    def errorSlot(self, base_node_id, message, *args):
+    def errorSlot(self, node_id, message):
         """
         Slot to receive events from the attached Node instance
         when the node wants to report an error.
 
-        :param base_node_id: base node identifier
+        :param node_id: node identifier
         :param message: error message
         """
 
-        self._last_error = "{message}".format(message=message)
+        if self:
+            self._last_error = "{message}".format(message=message)
 
     def setCustomToolTip(self):
         """
@@ -334,11 +278,14 @@ class NodeItem(QtSvgWidgets.QGraphicsSvgItem):
 
         return self._node_label
 
-    def _labelUnselectedSlot(self):
+    def setLabel(self, label):
         """
-        Called when user unselect the label
+        Sets the node label.
+
+        :param label: NoteItem instance.
         """
-        self.updateNode()
+
+        self._node_label = label
 
     def _centerLabel(self):
         """
@@ -352,7 +299,6 @@ class NodeItem(QtSvgWidgets.QGraphicsSvgItem):
         label_x_pos = node_middle.x() - text_middle.x()
         label_y_pos = -25
         self._node_label.setPos(label_x_pos, label_y_pos)
-        return
 
     def _showLabel(self):
         """
@@ -360,39 +306,12 @@ class NodeItem(QtSvgWidgets.QGraphicsSvgItem):
         """
 
         if not self._node_label:
-            self._node_label = LabelItem(self)
-            self._node_label.item_unselected_signal.connect(self._labelUnselectedSlot)
+            self._node_label = NoteItem(self)
             self._node_label.setEditable(False)
-            self._updateLabel()
-            self._node.setSettingValue("label", self._node_label.dump())
-
-    def _updateLabel(self):
-        """
-        Update the label using the information stored in the node
-        """
-        if not self._node_label:
-            return
-        self._node_label.setPlainText(self._node.name())
-        label_data = self._node.settings().get("label")
-
-        if self._node_label.toPlainText() != label_data["text"]:
-            self._node_label.setPlainText(label_data["text"])
-
-        style = label_data.get("style")
-        if style:
-            self._node_label.setStyle(style)
-        self._node_label.setRotation(label_data.get("rotation", 0))
-
-        if self._node.locked():
-            self._node_label.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable, False)
-
-        if label_data["x"] is None:
+            self._node_label.setPlainText(self._node.name())
             self._centerLabel()
-            self.updateNode()
-        else:
-            self._node_label.setPos(label_data["x"], label_data["y"])
 
-    def connectToPort(self, pos, unavailable_ports=[]):
+    def connectToPort(self, unavailable_ports=[]):
         """
         Shows a contextual menu for the user to choose port or auto-select one.
 
@@ -402,7 +321,7 @@ class NodeItem(QtSvgWidgets.QGraphicsSvgItem):
         """
 
         self._selected_port = None
-        menu = QtWidgets.QMenu(parent=self.scene().parent())
+        menu = QtWidgets.QMenu()
         ports = self._node.ports()
         if not ports:
             QtWidgets.QMessageBox.critical(self.scene().parent(), "Link", "No port available, please configure this device")
@@ -421,6 +340,7 @@ class NodeItem(QtSvgWidgets.QGraphicsSvgItem):
                 ports_dict[port.portNumber()] = port
             else:
                 ports_dict[port.name()] = port
+
         try:
             ports = sorted(ports_dict.keys(), key=int)
         except ValueError:
@@ -440,10 +360,7 @@ class NodeItem(QtSvgWidgets.QGraphicsSvgItem):
                 menu.addAction(QtGui.QIcon(':/icons/led_green.svg'), port_object.name())
 
         menu.triggered.connect(self.selectedPortSlot)
-        # add some delay before showing the menu
-        # https://github.com/GNS3/gns3-gui/issues/3169
-        QtCore.QThread.msleep(100)
-        menu.exec(pos)
+        menu.exec_(QtGui.QCursor.pos())
         return self._selected_port
 
     def selectedPortSlot(self, action):
@@ -470,28 +387,29 @@ class NodeItem(QtSvgWidgets.QGraphicsSvgItem):
         :param value: value of the change
         """
 
-        if change == QtWidgets.QGraphicsItem.GraphicsItemChange.ItemPositionChange and self._main_window.uiSnapToGridAction.isChecked() \
-                and self._allow_snap_to_grid:
-            grid_size = self._main_window.uiGraphicsView.nodeGridSize()
+        if change == QtWidgets.QGraphicsItem.ItemPositionHasChanged and self.isActive() and self._main_window.uiSnapToGridAction.isChecked():
+            GRID_SIZE = 75
             mid_x = self.boundingRect().width() / 2
-            value.setX((grid_size * round((value.x() + mid_x) / grid_size)) - mid_x)
+            tmp_x = (GRID_SIZE * round((self.x() + mid_x) / GRID_SIZE)) - mid_x
             mid_y = self.boundingRect().height() / 2
-            value.setY((grid_size * round((value.y() + mid_y) / grid_size)) - mid_y)
+            tmp_y = (GRID_SIZE * round((self.y() + mid_y) / GRID_SIZE)) - mid_y
+            if tmp_x != self.x() and tmp_y != self.y():
+                self.setPos(tmp_x, tmp_y)
 
         # dynamically change the renderer when this node item is selected/unselected.
-        if change == QtWidgets.QGraphicsItem.GraphicsItemChange.ItemSelectedChange:
+        if change == QtWidgets.QGraphicsItem.ItemSelectedChange:
             if value:
                 self.graphicsEffect().setEnabled(True)
             else:
                 self.graphicsEffect().setEnabled(False)
-                self.updateNode()
 
         # adjust link item positions when this node is moving or has changed.
-        if change == QtWidgets.QGraphicsItem.GraphicsItemChange.ItemPositionChange or change == QtWidgets.QGraphicsItem.GraphicsItemChange.ItemPositionHasChanged:
+        if change == QtWidgets.QGraphicsItem.ItemPositionChange or change == QtWidgets.QGraphicsItem.ItemPositionHasChanged:
+            self.setUnsavedState()
             for link in self._links:
                 link.adjust()
 
-        return super().itemChange(change, value)
+        return QtWidgets.QGraphicsItem.itemChange(self, change, value)
 
     def paint(self, painter, option, widget=None):
         """
@@ -504,16 +422,16 @@ class NodeItem(QtSvgWidgets.QGraphicsSvgItem):
 
         # don't show the selection rectangle
         if not self._settings["draw_rectangle_selected_item"]:
-            option.state = QtWidgets.QStyle.StateFlag.State_None
+            option.state = QtWidgets.QStyle.State_None
         super().paint(painter, option, widget)
 
         if not self._initialized or self.show_layer:
             brect = self.boundingRect()
             center = self.mapFromItem(self, brect.width() / 2.0, brect.height() / 2.0)
-            painter.setBrush(QtCore.Qt.GlobalColor.red)
-            painter.setPen(QtCore.Qt.GlobalColor.red)
-            painter.drawRect(QtCore.QRectF((brect.width() / 2.0) - 10, (brect.height() / 2.0) - 10, 20, 20))
-            painter.setPen(QtCore.Qt.GlobalColor.black)
+            painter.setBrush(QtCore.Qt.red)
+            painter.setPen(QtCore.Qt.red)
+            painter.drawRect((brect.width() / 2.0) - 10, (brect.height() / 2.0) - 10, 20, 20)
+            painter.setPen(QtCore.Qt.black)
             if self.show_layer:
                 text = str(int(self.zValue()))  # Z value
             elif self._last_error:
@@ -530,53 +448,21 @@ class NodeItem(QtSvgWidgets.QGraphicsSvgItem):
         """
 
         super().setZValue(value)
+        if self.zValue() < 0:
+            self.setFlag(self.ItemIsSelectable, False)
+            self.setFlag(self.ItemIsMovable, False)
+            if self._node_label:
+                self._node_label.setFlag(self.ItemIsSelectable, False)
+                self._node_label.setFlag(self.ItemIsMovable, False)
+        else:
+            self.setFlag(self.ItemIsSelectable, True)
+            self.setFlag(self.ItemIsMovable, True)
+            if self._node_label:
+                self._node_label.setFlag(self.ItemIsSelectable, True)
+                self._node_label.setFlag(self.ItemIsMovable, True)
         for link in self._links:
             link.adjust()
 
-    def keyPressEvent(self, event):
-        """
-        Handles all key press events
-
-        :param event: QKeyEvent
-        """
-
-        if event.modifiers() & QtCore.Qt.KeyboardModifier.AltModifier:
-            self._allow_snap_to_grid = False
-        else:
-            super().keyPressEvent(event)
-
-    def keyReleaseEvent(self, event):
-        """
-        Handles all key release events
-
-        :param event: QKeyEvent
-        """
-
-        self._allow_snap_to_grid = True
-
-    def locked(self):
-
-        return self._locked
-
-    def setLocked(self, locked):
-        """
-        Sets the locked value.
-
-        :param value: Z value
-        """
-
-        if locked is True:
-            self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable, False)
-            if self._node_label:
-                self._node_label.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable, False)
-        else:
-            self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable, True)
-            if self._node_label:
-                self._node_label.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable, True)
-        for link in self._links:
-            link.adjust()
-        self._locked = locked
-
     def hoverEnterEvent(self, event):
         """
         Handles all hover enter events for this item.
@@ -597,11 +483,3 @@ class NodeItem(QtSvgWidgets.QGraphicsSvgItem):
 
         if not self.isSelected():
             self.graphicsEffect().setEnabled(False)
-
-    def mouseRelease(self):
-        """
-        Handle all mouse release for this item.
-        It the item is select but mouse is not on it the event
-        is send also
-        """
-        self.updateNode()

gns3/items/note_item.py

@@ -15,19 +15,20 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+"""
+Graphical representation of a note on the QGraphicsScene.
+"""
+
 from ..qt import QtCore, QtWidgets, QtGui
-from .utils import colorFromSvg
 
 
-class LabelItem(QtWidgets.QGraphicsTextItem):
+class NoteItem(QtWidgets.QGraphicsTextItem):
     """
-    Label for links and nodes.
+    Text note for the QGraphicsView.
 
     :param parent: optional parent
     """
 
-    item_unselected_signal = QtCore.Signal()
-
     show_layer = False
 
     def __init__(self, parent=None):
@@ -42,7 +43,8 @@ class LabelItem(QtWidgets.QGraphicsTextItem):
         qt_font.fromString(view_settings["default_label_font"])
         self.setDefaultTextColor(QtGui.QColor(view_settings["default_label_color"]))
         self.setFont(qt_font)
-        self.setFlags(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable | QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsSelectable)
+        self.setFlag(self.ItemIsMovable)
+        self.setFlag(self.ItemIsSelectable)
         self.setZValue(2)
         self._editable = True
 
@@ -91,12 +93,12 @@ class LabelItem(QtWidgets.QGraphicsTextItem):
 
         key = event.key()
         modifiers = event.modifiers()
-        if key in (QtCore.Qt.Key.Key_P, QtCore.Qt.Key.Key_Plus, QtCore.Qt.Key.Key_Equal) and modifiers & QtCore.Qt.KeyboardModifier.AltModifier \
-                or key == QtCore.Qt.Key.Key_Plus and modifiers & QtCore.Qt.KeyboardModifier.AltModifier and modifiers & QtCore.Qt.KeyboardModifier.KeypadModifier:
+        if key in (QtCore.Qt.Key_P, QtCore.Qt.Key_Plus, QtCore.Qt.Key_Equal) and modifiers & QtCore.Qt.AltModifier \
+                or key == QtCore.Qt.Key_Plus and modifiers & QtCore.Qt.AltModifier and modifiers & QtCore.Qt.KeypadModifier:
             if self.rotation() > -360.0:
                 self.setRotation(self.rotation() - 1)
-        elif key in (QtCore.Qt.Key.Key_M, QtCore.Qt.Key.Key_Minus) and modifiers & QtCore.Qt.KeyboardModifier.AltModifier \
-                or key == QtCore.Qt.Key.Key_Minus and modifiers & QtCore.Qt.KeyboardModifier.AltModifier and modifiers & QtCore.Qt.KeyboardModifier.KeypadModifier:
+        elif key in (QtCore.Qt.Key_M, QtCore.Qt.Key_Minus) and modifiers & QtCore.Qt.AltModifier \
+                or key == QtCore.Qt.Key_Minus and modifiers & QtCore.Qt.AltModifier and modifiers & QtCore.Qt.KeypadModifier:
             if self.rotation() < 360.0:
                 self.setRotation(self.rotation() + 1)
         else:
@@ -107,11 +109,11 @@ class LabelItem(QtWidgets.QGraphicsTextItem):
         Edit mode for this note.
         """
 
-        self.setTextInteractionFlags(QtCore.Qt.TextInteractionFlag.TextEditorInteraction)
+        self.setTextInteractionFlags(QtCore.Qt.TextEditorInteraction)
         self.setSelected(True)
         self.setFocus()
         cursor = self.textCursor()
-        cursor.select(QtGui.QTextCursor.SelectionType.Document)
+        cursor.select(QtGui.QTextCursor.Document)
         self.setTextCursor(cursor)
 
     def mouseDoubleClickEvent(self, event):
@@ -131,12 +133,12 @@ class LabelItem(QtWidgets.QGraphicsTextItem):
         :param event: QFocusEvent instance
         """
 
-        self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsFocusable, False)
+        self.setFlag(QtWidgets.QGraphicsItem.ItemIsFocusable, False)
         cursor = self.textCursor()
         if cursor.hasSelection():
             cursor.clearSelection()
             self.setTextCursor(cursor)
-        self.setTextInteractionFlags(QtCore.Qt.TextInteractionFlag.NoTextInteraction)
+        self.setTextInteractionFlags(QtCore.Qt.NoTextInteraction)
         if not self.toPlainText():
             # delete the note if empty
             self.delete()
@@ -163,60 +165,27 @@ class LabelItem(QtWidgets.QGraphicsTextItem):
             return
 
         center = self.mapFromItem(self, brect.width() / 2.0, brect.height() / 2.0)
-        painter.setBrush(QtCore.Qt.GlobalColor.red)
-        painter.setPen(QtCore.Qt.GlobalColor.red)
-        painter.drawRect(QtCore.QRectF((brect.width() / 2.0) - 10, (brect.height() / 2.0) - 10, 20, 20))
-        painter.setPen(QtCore.Qt.GlobalColor.black)
+        painter.setBrush(QtCore.Qt.red)
+        painter.setPen(QtCore.Qt.red)
+        painter.drawRect((brect.width() / 2.0) - 10, (brect.height() / 2.0) - 10, 20, 20)
+        painter.setPen(QtCore.Qt.black)
         zval = str(int(self.zValue()))
-        painter.drawText(QtCore.QPointF(center.x(), center.y()), zval)
+        painter.drawText(QtCore.QPointF(center.x() - 4, center.y() + 4), zval)
 
-    def setStyle(self, new_style):
+    def setZValue(self, value):
         """
-        Set text style using a SVG style
-        """
-        font = QtGui.QFont()
-        for style in new_style.split(";"):
-            if ":" in style:
-                key, val = style.split(":")
-                key = key.strip()
-                val = val.strip()
+        Sets a new Z value.
 
-                if key == "font-size":
-                    font.setPointSizeF(float(val))
-                elif key == "font-family":
-                    font.setFamily(val)
-                elif key == "font-style" and val == "italic":
-                    font.setItalic(True)
-                elif key == "font-weight" and val == "bold":
-                    font.setBold(True)
-                elif key == "text-decoration" and val == "underline":
-                    font.setUnderline(True)
-                elif key == "text-decoration" and val == "line-through":
-                    font.setStrikeOut(True)
-                elif key == "fill":
-                    new_color = colorFromSvg(val)
-                    color = self.defaultTextColor()
-                    color.setBlue(new_color.blue())
-                    color.setRed(new_color.red())
-                    color.setGreen(new_color.green())
-                    self.setDefaultTextColor(color)
-                elif key == "fill-opacity":
-                    color = self.defaultTextColor()
-                    color.setAlphaF(float(val))
-                    self.setDefaultTextColor(color)
-        self.setFont(font)
-
-    def itemChange(self, change, value):
+        :param value: Z value
         """
-        Notifies this node item that some part of the item's state changes.
 
-        :param change: GraphicsItemChange type
-        :param value: value of the change
-        """
-        if change == QtWidgets.QGraphicsItem.GraphicsItemChange.ItemSelectedChange:
-            if value == 0:
-                self.item_unselected_signal.emit()
-        return super().itemChange(change, value)
+        super().setZValue(value)
+        if self.zValue() < 0:
+            self.setFlag(self.ItemIsSelectable, False)
+            self.setFlag(self.ItemIsMovable, False)
+        else:
+            self.setFlag(self.ItemIsSelectable, True)
+            self.setFlag(self.ItemIsMovable, True)
 
     def dump(self):
         """
@@ -226,29 +195,63 @@ class LabelItem(QtWidgets.QGraphicsTextItem):
         """
 
         note_info = {"text": self.toPlainText(),
-                     "x": int(self.x()),
-                     "y": int(self.y()),
-                     "rotation": int(self.rotation())}
+                     "x": self.x(),
+                     "y": self.y()}
 
-        style = ""
-
-        style += "font-family: {};".format(self.font().family())
-        style += "font-size: {};".format(self.font().pointSizeF())
-
-        if self.font().italic():
-            style += "font-style: italic;"
-
-        if self.font().bold():
-            style += "font-weight: bold;"
-
-        if self.font().strikeOut():
-            style += "text-decoration: line-through;"
-        elif self.font().underline():
-            style += "text-decoration: underline;"
-
-        style += "fill: {};".format("#" + hex(self.defaultTextColor().rgba())[4:])
-        style += "fill-opacity: {};".format(self.defaultTextColor().alphaF())
-
-        note_info["style"] = style
+        note_info["font"] = self.font().toString()
+        note_info["color"] = self.defaultTextColor().name(QtGui.QColor.HexArgb)
+        if self.rotation() != 0:
+            note_info["rotation"] = self.rotation()
+        if self.zValue() != 2:
+            note_info["z"] = self.zValue()
 
         return note_info
+
+    def load(self, note_info):
+        """
+        Loads a note representation
+        (from a topology file).
+
+        :param note_info: representation of the note (dictionary)
+        """
+
+        # load mandatory properties
+        text = note_info["text"]
+        x = note_info["x"]
+        y = note_info["y"]
+
+        self.setPlainText(text)
+        self.setPos(x, y)
+
+        # load optional properties
+        font = note_info.get("font")
+        color = note_info.get("color")
+        rotation = note_info.get("rotation")
+        z = note_info.get("z")
+
+        if font:
+            qt_font = QtGui.QFont()
+            if qt_font.fromString(font):
+                self.setFont(qt_font)
+        if color:
+            self.setDefaultTextColor(QtGui.QColor(color))
+        if rotation is not None:
+            self.setRotation(float(rotation))
+        if z is not None:
+            self.setZValue(z)
+
+    def duplicate(self):
+        """
+        Duplicates this node item.
+
+        :return: NoteItem instance
+        """
+
+        note_item = NoteItem(self.parent())
+        note_item.setPlainText(self.toPlainText())
+        note_item.setPos(self.x() + 20, self.y() + 20)
+        note_item.setZValue(self.zValue())
+        note_item.setFont(self.font())
+        note_item.setDefaultTextColor(self.defaultTextColor())
+        note_item.setRotation(self.rotation())
+        return note_item

gns3/items/pixmap_image_item.py

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+#
+# 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/>.
+
+"""
+Graphical representation of a Pixmap image on the QGraphicsScene.
+"""
+
+from ..qt import QtCore, QtWidgets
+from .image_item import ImageItem
+
+
+class PixmapImageItem(ImageItem, QtWidgets.QGraphicsPixmapItem):
+
+    """
+    Class to insert an pixmap image on the scene.
+    """
+
+    def __init__(self, pixmap, image_path, pos=None):
+
+        QtWidgets.QGraphicsPixmapItem.__init__(self, pixmap)
+        ImageItem.__init__(self, image_path, pos)
+        self.setTransformationMode(QtCore.Qt.SmoothTransformation)
+
+    def duplicate(self):
+        """
+        Duplicates this image item.
+
+        :return: PixmapImageItem instance
+        """
+
+        image_item = PixmapImageItem(self.pixmap(), self._image_path, QtCore.QPointF(self.x() + 20, self.y() + 20))
+        image_item.setZValue(self.zValue())
+        return image_item

gns3/items/rectangle_item.py

@@ -19,8 +19,6 @@
 Graphical representation of a rectangle on the QGraphicsScene.
 """
 
-import xml.etree.ElementTree as ET
-
 from ..qt import QtCore, QtGui, QtWidgets
 from .shape_item import ShapeItem
 
@@ -31,22 +29,25 @@ class RectangleItem(QtWidgets.QGraphicsRectItem, ShapeItem):
     Class to draw a rectangle on the scene.
     """
 
-    def __init__(self, width=200, height=100, **kws):
-        self._rx = 0
-        self._ry = 0
-        super().__init__(width=width, height=height, **kws)
+    def __init__(self, pos=None, width=200, height=100):
 
-    def setHorizontalCornerRadius(self, radius: int):
-        self._rx = radius
+        super().__init__()
+        self.setRect(0, 0, width, height)
+        pen = QtGui.QPen(QtCore.Qt.black, 2, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin)
+        self.setPen(pen)
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255, 255))  # default color is white and not transparent
+        self.setBrush(brush)
+        if pos:
+            self.setPos(pos)
 
-    def horizontalCornerRadius(self):
-        return self._rx
+    def delete(self):
+        """
+        Deletes this rectangle.
+        """
 
-    def setVerticalCornerRadius(self, radius: int):
-        self._ry = radius
-
-    def verticalCornerRadius(self):
-        return self._ry
+        self.scene().removeItem(self)
+        from ..topology import Topology
+        Topology.instance().removeRectangle(self)
 
     def paint(self, painter, option, widget=None):
         """
@@ -57,43 +58,19 @@ class RectangleItem(QtWidgets.QGraphicsRectItem, ShapeItem):
         :param widget: QWidget instance
         """
 
-        painter.setPen(self.pen())
-        painter.setBrush(self.brush())
-        painter.drawRoundedRect(self.rect(), self._rx, self._ry)
+        super().paint(painter, option, widget)
         self.drawLayerInfo(painter)
 
-    def toSvg(self):
+    def duplicate(self):
         """
-        Return an SVG version of the shape
+        Duplicates this rectangle item.
+
+        :return: RectangleItem instance
         """
-        svg = ET.Element("svg")
-        svg.set("width", str(int(self.rect().width())))
-        svg.set("height", str(int(self.rect().height())))
 
-        rect = ET.SubElement(svg, "rect")
-        rect.set("width", str(int(self.rect().width())))
-        rect.set("height", str(int(self.rect().height())))
-        if self._rx:
-            rect.set("rx", str(self._rx))
-        if self._ry:
-            rect.set("ry", str(self._ry))
-
-        rect = self._styleSvg(rect)
-
-        return ET.tostring(svg, encoding="utf-8").decode("utf-8")
-
-    def fromSvg(self, svg):
-        svg_elem = ET.fromstring(svg)
-        if len(svg_elem):
-            # handle horizontal corner radius and vertical corner radius (specific to rectangles)
-            rx = svg_elem[0].get("rx")
-            ry = svg_elem[0].get("ry")
-            if rx:
-                self._rx = int(rx)
-            elif ry:
-                self._rx = int(ry)  # defaults to ry if it is specified
-            if ry:
-                self._ry = int(ry)
-            elif rx:
-                self._ry = int(rx)  # defaults to rx if it is specified
-        super().fromSvg(svg)
+        rectangle_item = RectangleItem(QtCore.QPointF(self.x() + 20, self.y() + 20), self.rect().width(), self.rect().height())
+        rectangle_item.setPen(self.pen())
+        rectangle_item.setBrush(self.brush())
+        rectangle_item.setZValue(self.zValue())
+        rectangle_item.setRotation(self.rotation())
+        return rectangle_item

gns3/items/serial_link_item.py

@@ -22,7 +22,7 @@ Graphical representation of a Serial link on the QGraphicsScene.
 import math
 from ..qt import QtCore, QtGui, QtWidgets
 from .link_item import LinkItem
-from .label_item import LabelItem
+from .note_item import NoteItem
 from ..ports.port import Port
 
 
@@ -37,11 +37,12 @@ class SerialLinkItem(LinkItem):
     :param destination_port: destination Port instance
     :param link: Link instance (contains back-end stuff for this link)
     :param adding_flag: indicates if this link is being added (no destination yet)
+    :param multilink: used to draw multiple link between the same source and destination
     """
 
-    def __init__(self, source_item, source_port, destination_item, destination_port, link=None, adding_flag=False):
+    def __init__(self, source_item, source_port, destination_item, destination_port, link=None, adding_flag=False, multilink=0):
 
-        super().__init__(source_item, source_port, destination_item, destination_port, link, adding_flag)
+        super().__init__(source_item, source_port, destination_item, destination_port, link, adding_flag, multilink)
 
     def adjust(self):
         """
@@ -50,16 +51,10 @@ class SerialLinkItem(LinkItem):
 
         LinkItem.adjust(self)
 
-        try:
-            if self._hovered:
-                self.setPen(QtGui.QPen(QtCore.Qt.GlobalColor.red, self._link._link_style["width"] + 1, QtCore.Qt.PenStyle.SolidLine, QtCore.Qt.PenCapStyle.RoundCap, QtCore.Qt.PenJoinStyle.RoundJoin))
-            else:
-                self.setPen(QtGui.QPen(QtGui.QColor(self._link._link_style["color"]), self._link._link_style["width"], QtCore.Qt.PenStyle(self._link._link_style["type"]), QtCore.Qt.PenCapStyle.RoundCap, QtCore.Qt.PenJoinStyle.RoundJoin))
-        except:
-            if self._hovered:
-                self.setPen(QtGui.QPen(QtCore.Qt.GlobalColor.red, self._pen_width + 1, QtCore.Qt.PenStyle.SolidLine, QtCore.Qt.PenCapStyle.RoundCap, QtCore.Qt.PenJoinStyle.RoundJoin))
-            else:
-                self.setPen(QtGui.QPen(QtCore.Qt.GlobalColor.darkRed, self._pen_width, QtCore.Qt.PenStyle.SolidLine, QtCore.Qt.PenCapStyle.RoundCap, QtCore.Qt.PenJoinStyle.RoundJoin))
+        if self._hovered:
+            self.setPen(QtGui.QPen(QtCore.Qt.red, self._pen_width + 1, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin))
+        else:
+            self.setPen(QtGui.QPen(QtCore.Qt.darkRed, self._pen_width, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin))
 
         # get source to destination angle
         vector_angle = math.atan2(self.dy, self.dx)
@@ -113,73 +108,76 @@ class SerialLinkItem(LinkItem):
 
         QtWidgets.QGraphicsPathItem.paint(self, painter, option, widget)
 
-        if not self._adding_flag:
+        if not self._adding_flag and self._settings["draw_link_status_points"]:
 
             # points disappears if nodes are too close to each others.
             if self.length < 80:
                 return
 
             # source point color
-            if self._link.suspended() or self._source_port.status() == Port.suspended:
-                # link or port is suspended
-                shape = QtCore.Qt.PenCapStyle.RoundCap
-                color = QtCore.Qt.GlobalColor.yellow
-            elif self._source_port.status() == Port.started:
+            if self._source_port.status() == Port.started:
                 # port is active
-                shape = QtCore.Qt.PenCapStyle.RoundCap
-                color = QtCore.Qt.GlobalColor.green
+                color = QtCore.Qt.green
+            elif self._source_port.status() == Port.suspended:
+                # port is suspended
+                color = QtCore.Qt.yellow
             else:
-                shape = QtCore.Qt.PenCapStyle.SquareCap
-                color = QtCore.Qt.GlobalColor.red
+                color = QtCore.Qt.red
 
-            painter.setPen(QtGui.QPen(color, self._point_size, QtCore.Qt.PenStyle.SolidLine, shape, QtCore.Qt.PenJoinStyle.MiterJoin))
+            painter.setPen(QtGui.QPen(color, self._point_size, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.MiterJoin))
 
             source_port_label = self._source_port.label()
-            if source_port_label is None:
-                source_port_label = LabelItem(self._source_item)
-                source_port_label.setPlainText(self._source_port.shortName())
-                source_port_label.setPos(self.mapToItem(self._source_item, self.source))
-                self._source_port.setLabel(source_port_label)
-
             if self._draw_port_labels:
-                source_port_label.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable, not self._source_item.locked())
-                source_port_label.show()
-            else:
+                if source_port_label is None:
+                    source_port_label = NoteItem(self._source_item)
+                    if not self._source_port.isStub():
+                        source_port_name = self._source_port.name().replace(self._source_port.longNameType(),
+                                                                            self._source_port.shortNameType())
+                    else:
+                        source_port_name = self._source_port.name()
+                    source_port_label.setPlainText(source_port_name)
+                    source_port_label.setPos(self.mapToItem(self._source_item, self.source))
+                    self._source_port.setLabel(source_port_label)
+
+                elif source_port_label and not source_port_label.isVisible():
+                    source_port_label.show()
+
+            elif source_port_label:
                 source_port_label.hide()
 
-            if self._settings["draw_link_status_points"] and self.pen().style() != QtCore.Qt.PenStyle.NoPen:
-                painter.drawPoint(self.source_point)
+            painter.drawPoint(self.source_point)
 
             # destination point color
-            if self._link.suspended() or self._destination_port.status() == Port.suspended:
-                # link or port is suspended
-                color = QtCore.Qt.GlobalColor.yellow
-                shape = QtCore.Qt.PenCapStyle.RoundCap
-            elif self._destination_port.status() == Port.started:
+            if self._destination_port.status() == Port.started:
                 # port is active
-                color = QtCore.Qt.GlobalColor.green
-                shape = QtCore.Qt.PenCapStyle.RoundCap
+                color = QtCore.Qt.green
+            elif self._destination_port.status() == Port.suspended:
+                # port is suspended
+                color = QtCore.Qt.yellow
             else:
-                color = QtCore.Qt.GlobalColor.red
-                shape = QtCore.Qt.PenCapStyle.SquareCap
+                color = QtCore.Qt.red
 
-            painter.setPen(QtGui.QPen(color, self._point_size, QtCore.Qt.PenStyle.SolidLine, shape, QtCore.Qt.PenJoinStyle.MiterJoin))
+            painter.setPen(QtGui.QPen(color, self._point_size, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.MiterJoin))
 
             destination_port_label = self._destination_port.label()
-
-            if destination_port_label is None:
-                destination_port_label = LabelItem(self._destination_item)
-                destination_port_label.setPlainText(self._destination_port.shortName())
-                destination_port_label.setPos(self.mapToItem(self._destination_item, self.destination))
-                self._destination_port.setLabel(destination_port_label)
-
             if self._draw_port_labels:
-                destination_port_label.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable, not self._destination_item.locked())
-                destination_port_label.show()
-            else:
+                if destination_port_label is None:
+                    destination_port_label = NoteItem(self._destination_item)
+                    if not self._destination_port.isStub():
+                        destination_port_name = self._destination_port.name().replace(self._destination_port.longNameType(),
+                                                                                      self._destination_port.shortNameType())
+                    else:
+                        destination_port_name = self._destination_port.name()
+                    destination_port_label.setPlainText(destination_port_name)
+                    destination_port_label.setPos(self.mapToItem(self._destination_item, self.destination))
+                    self._destination_port.setLabel(destination_port_label)
+
+                elif destination_port_label and not destination_port_label.isVisible():
+                    destination_port_label.show()
+
+            elif destination_port_label:
                 destination_port_label.hide()
 
-            if self._settings["draw_link_status_points"] and self.pen().style() != QtCore.Qt.PenStyle.NoPen:
-                painter.drawPoint(self.destination_point)
+            painter.drawPoint(self.destination_point)
 
-        self._drawSymbol()
+        self._drawCaptureSymbol()

gns3/items/shape_item.py

@@ -19,39 +19,46 @@
 Base class for shape items (Rectangle, ellipse etc.).
 """
 
-import xml.etree.ElementTree as ET
 from ..qt import QtCore, QtGui, QtWidgets
-from .drawing_item import DrawingItem
-from .utils import colorFromSvg
-
-import logging
-log = logging.getLogger(__name__)
 
 
-class ShapeItem(DrawingItem):
+class ShapeItem:
 
     """
     Base class to draw shapes on the scene.
     """
 
-    def __init__(self, width=200, height=200, svg=None, **kws):
+    show_layer = False
 
-        super().__init__(svg=svg, **kws)
+    def __init__(self, **kws):
+
+        self.setFlags(QtWidgets.QGraphicsItem.ItemIsMovable | QtWidgets.QGraphicsItem.ItemIsFocusable | QtWidgets.QGraphicsItem.ItemIsSelectable)
         self.setAcceptHoverEvents(True)
         self._border = 5
         self._edge = None
-        self._originally_movable = True
 
-        if svg is None:
-            self.setRect(0, 0, width, height)
-            pen = QtGui.QPen(QtCore.Qt.GlobalColor.black, 2, QtCore.Qt.PenStyle.SolidLine, QtCore.Qt.PenCapStyle.RoundCap, QtCore.Qt.PenJoinStyle.RoundJoin)
-            self.setPen(pen)
-            brush = QtGui.QBrush(QtGui.QColor(255, 255, 255, 255))  # default color is white and not transparent
-            self.setBrush(brush)
+        from ..main_window import MainWindow
+        self._graphics_view = MainWindow.instance().uiGraphicsView
+
+    def keyPressEvent(self, event):
+        """
+        Handles all key press events
+
+        :param event: QKeyEvent
+        """
+
+        key = event.key()
+        modifiers = event.modifiers()
+        if key in (QtCore.Qt.Key_P, QtCore.Qt.Key_Plus, QtCore.Qt.Key_Equal) and modifiers & QtCore.Qt.AltModifier \
+                or key == QtCore.Qt.Key_Plus and modifiers & QtCore.Qt.AltModifier and modifiers & QtCore.Qt.KeypadModifier:
+            if self.rotation() > -360.0:
+                self.setRotation(self.rotation() - 1)
+        elif key in (QtCore.Qt.Key_M, QtCore.Qt.Key_Minus) and modifiers & QtCore.Qt.AltModifier \
+                or key == QtCore.Qt.Key_Minus and modifiers & QtCore.Qt.AltModifier and modifiers & QtCore.Qt.KeypadModifier:
+            if self.rotation() < 360.0:
+                self.setRotation(self.rotation() + 1)
         else:
-            self.fromSvg(svg)
-        if self._id is None:
-            self.create()
+            QtWidgets.QGraphicsItem.keyPressEvent(self, event)
 
     def mousePressEvent(self, event):
         """
@@ -61,22 +68,22 @@ class ShapeItem(DrawingItem):
         """
 
         self.update()
-        self._originally_movable = bool(self.flags() & QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable)
         if event.pos().x() > (self.rect().right() - self._border):
-            self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable, False)
+            self.setFlag(QtWidgets.QGraphicsItem.ItemIsMovable, False)
             self._edge = "right"
 
         elif event.pos().x() < (self.rect().left() + self._border):
-            self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable, False)
+            self.setFlag(QtWidgets.QGraphicsItem.ItemIsMovable, False)
             self._edge = "left"
 
         elif event.pos().y() < (self.rect().top() + self._border):
-            self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable, False)
+            self.setFlag(QtWidgets.QGraphicsItem.ItemIsMovable, False)
             self._edge = "top"
 
         elif event.pos().y() > (self.rect().bottom() - self._border):
-            self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable, False)
+            self.setFlag(QtWidgets.QGraphicsItem.ItemIsMovable, False)
             self._edge = "bottom"
+
         QtWidgets.QGraphicsItem.mousePressEvent(self, event)
 
     def mouseReleaseEvent(self, event):
@@ -87,7 +94,7 @@ class ShapeItem(DrawingItem):
         """
 
         self.update()
-        self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable, self._originally_movable)
+        self.setFlag(QtWidgets.QGraphicsItem.ItemIsMovable)
         self._edge = None
         QtWidgets.QGraphicsItem.mouseReleaseEvent(self, event)
 
@@ -147,18 +154,18 @@ class ShapeItem(DrawingItem):
         :param event: QGraphicsSceneHoverEvent instance
         """
 
-        # locked objects don't need cursors
-        if not self.locked():
+        # objects on the background layer don't need cursors
+        if self.zValue() >= 0:
             if event.pos().x() > (self.rect().right() - self._border):
-                self._graphics_view.setCursor(QtCore.Qt.CursorShape.SizeHorCursor)
+                self._graphics_view.setCursor(QtCore.Qt.SizeHorCursor)
             elif event.pos().x() < (self.rect().left() + self._border):
-                self._graphics_view.setCursor(QtCore.Qt.CursorShape.SizeHorCursor)
+                self._graphics_view.setCursor(QtCore.Qt.SizeHorCursor)
             elif event.pos().y() < (self.rect().top() + self._border):
-                self._graphics_view.setCursor(QtCore.Qt.CursorShape.SizeVerCursor)
+                self._graphics_view.setCursor(QtCore.Qt.SizeVerCursor)
             elif event.pos().y() > (self.rect().bottom() - self._border):
-                self._graphics_view.setCursor(QtCore.Qt.CursorShape.SizeVerCursor)
+                self._graphics_view.setCursor(QtCore.Qt.SizeVerCursor)
             else:
-                self._graphics_view.setCursor(QtCore.Qt.CursorShape.SizeAllCursor)
+                self._graphics_view.setCursor(QtCore.Qt.SizeAllCursor)
 
     def hoverLeaveEvent(self, event):
         """
@@ -167,39 +174,135 @@ class ShapeItem(DrawingItem):
         :param event: QGraphicsSceneHoverEvent instance
         """
 
-        # locked objects don't need cursors
-        if not self.locked():
-            self._graphics_view.setCursor(QtCore.Qt.CursorShape.ArrowCursor)
+        # objects on the background layer don't need cursors
+        if self.zValue() >= 0:
+            self._graphics_view.setCursor(QtCore.Qt.ArrowCursor)
 
-    def setWidthAndHeight(self, width, height):
-        self.setRect(0, 0, width, height)
-
-    def fromSvg(self, svg):
+    def drawLayerInfo(self, painter):
         """
-        Import element information from SVG
+        Draws the layer position.
+
+        :param painter: QPainter instance
         """
-        svg = ET.fromstring(svg)
-        width = float(svg.get("width", self.rect().width()))
-        height = float(svg.get("height", self.rect().height()))
+
+        if self.show_layer is False:
+            return
+
+        brect = self.boundingRect()
+        # don't draw anything if the object is too small
+        if brect.width() < 20 or brect.height() < 20:
+            return
+
+        center = self.mapFromItem(self, brect.width() / 2.0, brect.height() / 2.0)
+        painter.setBrush(QtCore.Qt.red)
+        painter.setPen(QtCore.Qt.red)
+        painter.drawRect((brect.width() / 2.0) - 10, (brect.height() / 2.0) - 10, 20, 20)
+        painter.setPen(QtCore.Qt.black)
+        zval = str(int(self.zValue()))
+        painter.drawText(QtCore.QPointF(center.x() - 4, center.y() + 4), zval)
+
+    def setZValue(self, value):
+        """
+        Sets a new Z value.
+
+        :param value: Z value
+        """
+
+        QtWidgets.QGraphicsItem.setZValue(self, value)
+        if self.zValue() < 0:
+            self.setFlag(self.ItemIsSelectable, False)
+            self.setFlag(self.ItemIsMovable, False)
+        else:
+            self.setFlag(self.ItemIsSelectable, True)
+            self.setFlag(self.ItemIsMovable, True)
+
+    def dump(self):
+        """
+        Returns a representation of this shape item.
+
+        :returns: dictionary
+        """
+
+        shape_info = {"width": self.rect().width(),
+                      "height": self.rect().height(),
+                      "x": self.x(),
+                      "y": self.y()}
+
+        brush = self.brush()
+        if brush.color() != QtCore.Qt.white:
+            shape_info["color"] = brush.color().name()
+        if brush.color().alpha() != 255:
+            shape_info["transparency"] = brush.color().alpha()
+
+        pen = self.pen()
+        if pen.color() != QtCore.Qt.black:
+            shape_info["border_color"] = pen.color().name()
+        if pen.color().alpha() != 255:
+            shape_info["border_transparency"] = pen.color().alpha()
+        if pen.width() != 2:
+            shape_info["border_width"] = pen.width()
+        if pen.style() != QtCore.Qt.SolidLine:
+            shape_info["border_style"] = pen.style()
+
+        if self.rotation() != 0:
+            shape_info["rotation"] = self.rotation()
+        if self.zValue() != 0:
+            shape_info["z"] = self.zValue()
+
+        return shape_info
+
+    def load(self, shape_info):
+        """
+        Loads a representation of this shape item.
+        (from a topology file).
+
+        :param shape_info: representation of the shape item (dictionary)
+        """
+
+        # load mandatory properties
+        width = shape_info["width"]
+        height = shape_info["height"]
+        x = shape_info["x"]
+        y = shape_info["y"]
         self.setRect(0, 0, width, height)
+        self.setPos(x, y)
 
-        pen = QtGui.QPen()
-        brush = QtGui.QBrush(QtCore.Qt.BrushStyle.SolidPattern)
+        # load optional properties
+        z = shape_info.get("z")
+        color = shape_info.get("color")
+        if not color and shape_info.get("fill_color"):
+            # compatibility with old 1.0 projects
+            color = shape_info.get("fill_color")
+        transparency = shape_info.get("transparency")
+        border_color = shape_info.get("border_color")
+        border_transparency = shape_info.get("border_transparency")
+        border_width = shape_info.get("border_width")
+        border_style = shape_info.get("border_style")
+        rotation = shape_info.get("rotation")
 
-        if len(svg):
-            pen = self._penFromSVGElement(svg[0])
-            if svg[0].get("fill"):
-                new_color = colorFromSvg(svg[0].get("fill"))
-                color = brush.color()
-                color.setBlue(new_color.blue())
-                color.setRed(new_color.red())
-                color.setGreen(new_color.green())
-                brush.setColor(color)
-            if svg[0].get("fill-opacity"):
-                color = brush.color()
-                color.setAlphaF(float(svg[0].get("fill-opacity")))
-                brush.setColor(color)
+        if color:
+            color = QtGui.QColor(color)
+        else:
+            color = QtGui.QColor(255, 255, 255)
+        if transparency is not None:
+            color.setAlpha(transparency)
+        self.setBrush(QtGui.QBrush(color))
 
+        pen = QtGui.QPen(QtCore.Qt.black, 2, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin)
+        if border_color:
+            border_color = QtGui.QColor(border_color)
+        else:
+            border_color = pen.color()
+        if border_transparency:
+            border_color.setAlpha(border_transparency)
+        pen.setColor(border_color)
+        if border_width is not None:
+            pen.setWidth(int(border_width))
+        if border_style is not None:
+            pen.setStyle(QtCore.Qt.PenStyle(border_style))
         self.setPen(pen)
-        self.setBrush(brush)
-        self.update()
+
+        if rotation is not None:
+            self.setRotation(rotation)
+        if z is not None:
+            self.setZValue(z)

gns3/items/svg_image_item.py

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+#
+# 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/>.
+
+"""
+Graphical representation of a SVG image on the QGraphicsScene.
+"""
+
+from ..qt import QtCore, QtSvg
+from .image_item import ImageItem
+
+
+class SvgImageItem(ImageItem, QtSvg.QGraphicsSvgItem):
+
+    """
+    Class to insert a SVG image on the scene.
+    """
+
+    def __init__(self, renderer, image_path, pos=None):
+
+        QtSvg.QGraphicsSvgItem.__init__(self)
+        ImageItem.__init__(self, image_path, pos)
+        self.setSharedRenderer(renderer)
+
+    def duplicate(self):
+        """
+        Duplicates this image item.
+
+        :return: SvgImageItem instance
+        """
+
+        image_item = SvgImageItem(self.renderer(), self._image_path, QtCore.QPointF(self.x() + 20, self.y() + 20))
+        image_item.setZValue(self.zValue())
+        return image_item

gns3/items/svg_node_item.py

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+#
+# 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/>.
+
+"""
+Graphical representation of a SVG node on the QGraphicsScene.
+"""
+
+from ..qt import QtSvg
+from ..qt.qimage_svg_renderer import QImageSvgRenderer
+from .node_item import NodeItem
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class SvgNodeItem(NodeItem, QtSvg.QGraphicsSvgItem):
+
+    """
+    SVG node for the scene.
+
+    :param node: Node instance
+    :param symbol: symbol for the node representation on the scene
+    """
+
+    def __init__(self, node, symbol=None):
+
+        QtSvg.QGraphicsSvgItem.__init__(self)
+        NodeItem.__init__(self, node)
+
+        # create renderer using symbols path/resource
+        if symbol:
+            renderer = QImageSvgRenderer(symbol)
+            if symbol != node.defaultSymbol():
+                renderer.setObjectName(symbol)
+        else:
+            renderer = QImageSvgRenderer(node.defaultSymbol())
+        self.setSharedRenderer(renderer)

gns3/items/text_item.py

@@ -1,203 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2014 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 xml.etree.ElementTree as ET
-
-from ..qt import QtCore, QtWidgets, QtGui
-from .drawing_item import DrawingItem
-from .utils import colorFromSvg
-
-
-import logging
-log = logging.getLogger(__name__)
-
-
-class TextItem(QtWidgets.QGraphicsTextItem, DrawingItem):
-    """
-    Text item for the QGraphicsView.
-    """
-
-    def __init__(self, svg=None, **kws):
-
-        super().__init__(**kws)
-
-        from ..main_window import MainWindow
-
-        main_window = MainWindow.instance()
-        view_settings = main_window.uiGraphicsView.settings()
-        qt_font = QtGui.QFont()
-        qt_font.fromString(view_settings["default_note_font"])
-        self.setDefaultTextColor(QtGui.QColor(view_settings["default_note_color"]))
-        self.setFont(qt_font)
-
-        if svg:
-            try:
-                svg = self.fromSvg(svg)
-            except ET.ParseError as e:
-                log.warning(str(e))
-
-        # re-evaluate `z` position after creation
-        if 'z' in kws.keys():
-            self.setZValue(kws['z'])
-
-        if self._id is None:
-            self.create()
-
-    def editText(self):
-        """
-        Edit mode for this note.
-        """
-
-        self.setTextInteractionFlags(QtCore.Qt.TextInteractionFlag.TextEditorInteraction)
-        self.setSelected(True)
-        self.setFocus()
-        cursor = self.textCursor()
-        cursor.select(QtGui.QTextCursor.SelectionType.Document)
-        self.setTextCursor(cursor)
-
-    def mouseDoubleClickEvent(self, event):
-        """
-        Handles all mouse double click events.
-
-        :param event: QMouseEvent instance
-        """
-
-        self.editText()
-
-    def focusOutEvent(self, event):
-        """
-        Handles all focus out events.
-
-        :param event: QFocusEvent instance
-        """
-
-        self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsFocusable, False)
-        cursor = self.textCursor()
-        if cursor.hasSelection():
-            cursor.clearSelection()
-            self.setTextCursor(cursor)
-        self.setTextInteractionFlags(QtCore.Qt.TextInteractionFlag.NoTextInteraction)
-        if not self.toPlainText():
-            # delete the note if empty
-            self.delete()
-            return
-        else:
-            self.updateDrawing()
-        return super().focusOutEvent(event)
-
-    def paint(self, painter, option, widget=None):
-        """
-        Paints the contents of an item in local coordinates.
-
-        :param painter: QPainter instance
-        :param option: QStyleOptionGraphicsItem instance
-        :param widget: QWidget instance
-        """
-
-        super().paint(painter, option, widget)
-        self.drawLayerInfo(painter)
-
-    def toSvg(self):
-        """
-        Return an SVG version of the text
-        """
-        svg = ET.Element("svg")
-        svg.set("width", str(int(self.boundingRect().width())))
-        svg.set("height", str(int(self.boundingRect().height())))
-
-        text = ET.SubElement(svg, "text")
-        text.set("font-family", self.font().family())
-        text.set("font-size", str(self.font().pointSizeF()))
-        if self.font().italic():
-            text.set("font-style", "italic")
-        if self.font().bold():
-            text.set("font-weight", "bold")
-        if self.font().strikeOut():
-            text.set("text-decoration", "line-through")
-        elif self.font().underline():
-            text.set("text-decoration", "underline")
-        text.set("fill", "#" + hex(self.defaultTextColor().rgba())[4:])
-        text.set("fill-opacity", str(self.defaultTextColor().alphaF()))
-        text.text = self.toPlainText() or " "
-
-        svg = ET.tostring(svg, encoding="utf-8").decode("utf-8")
-        return svg
-
-    def fromSvg(self, svg):
-
-        # sometimes we receive \0 at the end of string inside <svg> element
-        try:
-            svg = svg.replace("\u0000", "")
-        except AttributeError:
-            pass
-
-        try:
-            svg = ET.fromstring(svg)
-        except ET.ParseError:
-            self.setPlainText("Unable to parse `text_item`")
-            return
-
-        text = svg[0]
-
-        font = QtGui.QFont()
-        color = text.get("fill")
-        if color:
-            new_color = colorFromSvg(color)
-            color = self.defaultTextColor()
-            color.setBlue(new_color.blue())
-            color.setRed(new_color.red())
-            color.setGreen(new_color.green())
-            self.setDefaultTextColor(color)
-
-        opacity = text.get("fill-opacity")
-        if opacity:
-            color = self.defaultTextColor()
-            color.setAlphaF(float(opacity))
-            self.setDefaultTextColor(color)
-
-        font.setPointSizeF(float(text.get("font-size", self.font().pointSizeF())))
-        font.setFamily(text.get("font-family", self.font().family()))
-        if text.get("font-style") == "italic":
-            font.setItalic(True)
-        if text.get("font-weight") == "bold":
-            font.setBold(True)
-        if text.get("text-decoration") == "underline":
-            font.setUnderline(True)
-        if text.get("text-decoration") == "line-through":
-            font.setStrikeOut(True)
-
-        self.setFont(font)
-        self.setPlainText(text.text)
-
-    def editable(self):
-        """
-        Returns either the note is editable or not.
-
-        :return: boolean
-        """
-
-        return True
-
-    def keyPressEvent(self, event):
-        """
-        Handles all key press events
-
-        :param event: QKeyEvent
-        """
-
-        if not self.handleKeyPressEvent(event):
-            super().keyPressEvent(event)

gns3/link.py

@@ -19,13 +19,10 @@
 Manages and stores everything needed for a connection between 2 devices.
 """
 
-import re
-from .qt import sip
-import uuid
-
-from .qt import QtCore, QtNetwork
-from .controller import Controller
 
+from .qt import QtCore
+from .nios.nio_udp import NIOUDP
+from .nios.nio_vmnet import NIOVMNET
 
 import logging
 log = logging.getLogger(__name__)
@@ -40,28 +37,24 @@ class Link(QtCore.QObject):
     :param source_port: source Port instance
     :param destination_node: destination Node instance
     :param destination_port: destination Port instance
+    :param stub: indicates if the link is connected to a stub device like a Cloud
     """
 
     # signals used to let the GUI view know about link
     # additions and deletions.
     add_link_signal = QtCore.Signal(int)
     delete_link_signal = QtCore.Signal(int)
-    updated_link_signal = QtCore.Signal(int)
-    error_link_signal = QtCore.Signal(int)
 
     _instance_count = 1
 
-    def __init__(self, source_node, source_port, destination_node, destination_port, link_id=None, **link_data):
-        """
-        :param link_data: Link information from the API
-        """
+    def __init__(self, source_node, source_port, destination_node, destination_port):
 
         super().__init__()
 
-        log.debug("adding link from {} {} to {} {}".format(source_node.name(),
-                                                           source_port.name(),
-                                                           destination_node.name(),
-                                                           destination_port.name()))
+        log.info("adding link from {} {} to {} {}".format(source_node.name(),
+                                                          source_port.name(),
+                                                          destination_node.name(),
+                                                          destination_port.name()))
 
         # create an unique ID
         self._id = Link._instance_count
@@ -71,223 +64,56 @@ class Link(QtCore.QObject):
         self._source_port = source_port
         self._destination_node = destination_node
         self._destination_port = destination_port
-        self._source_label = None
-        self._destination_label = None
-        self._link_id = link_id
-        self._capturing = False
-        self._deleting = False
-        self._capture_file_path = None
-        self._capture_file = None
-        self._network_manager = None
-        self._response_stream = None
-        self._capture_compute_id = None
-        self._initialized = False
-        self._filters = {}
-        self._suspend = False
-        self._nodes = []
+        self._source_nio = None
+        self._destination_nio = None
+        self._source_nio_active = False
+        self._destination_nio_active = False
 
-        # Boolean if True we are creating the first instance of this node
-        # if false the node already exist in the topology
-        # use to avoid erasing information when reloading
-        self._creator = False
-
-        # Add the default link style from the topology view settings
-        from .main_window import MainWindow
-        topology_view_settings = MainWindow.instance().uiGraphicsView.settings()
-        self._link_style = {
-            "color": topology_view_settings.get("default_link_color", "#000000"),
-            "width": topology_view_settings.get("default_link_width", 2),
-            "type": topology_view_settings.get("default_link_type", 1)
-        }
-
-        body = self._prepareParams()
-        if self._link_id:
-            link_data["link_id"] = self._link_id
-            self._linkCreatedCallback(link_data)
+        if source_port.isStub() or destination_port.isStub():
+            self._stub = True
         else:
-            self._link_id = str(uuid.uuid4())
-            self._creator = True
-            Controller.instance().post("/projects/{project_id}/links".format(project_id=source_node.project().id()), self._linkCreatedCallback, body=body)
+            self._stub = False
+        # we must request UDP information if the NIO is a NIO UDP and before
+        # it can be created.
+        if not self._stub:
+            # connect signals used when a NIO has been created by a node
+            # and this NIO need to be attached to a port connected to this link
+            source_node.nio_signal.connect(self.newNIOSlot)
+            destination_node.nio_signal.connect(self.newNIOSlot)
 
-    def _parseResponse(self, result):
+            # currently, we support only NIO_UDP and NIO_VMNET for normal connections (non-stub).
+            if source_port.defaultNio() == NIOUDP:
+                assert destination_port.defaultNio() == NIOUDP
+                self._source_udp = None
+                self._destination_udp = None
 
-        self._capturing = result.get("capturing", False)
-        if self._capturing:
-            self._capture_compute_id = result.get("capture_compute_id", None)
-            self._capture_file_path = result.get("capture_file_path", None)
-            if Controller.instance().isRemote() or (self._capture_compute_id and self._capture_compute_id != "local"):
-                # We need to stream the pcap file content if the controller or compute is remote
-                if Controller.instance().isRemote() or self._capture_file_path is None:
-                    self._capture_file = QtCore.QTemporaryFile()
-                    self._capture_file.open(QtCore.QIODeviceBase.OpenModeFlag.WriteOnly)
-                    self._capture_file.setAutoRemove(True)
-                    self._capture_file_path = self._capture_file.fileName()
-                else:
-                    self._capture_file = QtCore.QFile(self._capture_file_path)
-                    self._capture_file.open(QtCore.QIODeviceBase.OpenModeFlag.WriteOnly)
-                if self._network_manager is None:
-                    self._network_manager = QtNetwork.QNetworkAccessManager(self)
-                self._response_stream = Controller.instance().get("/projects/{project_id}/links/{link_id}/pcap".format(project_id=self.project().id(), link_id=self._link_id),
-                                                                  None,
-                                                                  showProgress=False,
-                                                                  downloadProgressCallback=self._downloadPcapProgress,
-                                                                  ignoreErrors=True,  # If something is wrong avoid disconnect us from server
-                                                                  timeout=None,
-                                                                  networkManager=self._network_manager)
-            log.debug("Has successfully started capturing packets on link {} to '{}'".format(self._link_id, self._capture_file_path))
-        else:
-            self._response_stream = None
+                # connect signals used to receive a UDP port and host allocated by a node
+                source_node.allocate_udp_nio_signal.connect(self.UDPPortAllocatedSlot)
+                destination_node.allocate_udp_nio_signal.connect(self.UDPPortAllocatedSlot)
 
-        if "nodes" in result:
-            self._nodes = result["nodes"]
-            self._updateLabels()
-        if "filters" in result:
-            self._filters = result["filters"]
-        if "link_style" in result:
-            self._link_style = result["link_style"]
-        if "suspend" in result:
-            self._suspend = result["suspend"]
-        self.updated_link_signal.emit(self._id)
-
-    def creator(self):
-        return self._creator
-
-    def suspended(self):
-        return self._suspend
-
-    def toggleSuspend(self):
-        self._suspend = not self._suspend
-        self.update()
-
-    def initialized(self):
-        return self._initialized
-
-    def addPortLabel(self, port, label):
-        if port.adapterNumber() == self._source_port.adapterNumber() and port.portNumber() == self._source_port.portNumber() and port.destinationNode() == self._destination_node:
-            self._source_label = label
-        else:
-            self._destination_label = label
-        label.item_unselected_signal.connect(self.update)
-        if self.creator():
-            self.update()
-        else:
-            self._updateLabels()
-
-    def update(self):
-        if not self._link_id or self.deleting():
-            return
-        body = self._prepareParams()
-        Controller.instance().put("/projects/{project_id}/links/{link_id}".format(project_id=self._source_node.project().id(), link_id=self._link_id), self.updateLinkCallback, body=body)
-
-    def listAvailableFilters(self, callback):
-        """
-        Get the list of available filters
-        """
-        Controller.instance().get("/projects/{project_id}/links/{link_id}/available_filters".format(project_id=self._source_node.project().id(), link_id=self._link_id), callback)
-
-    def updateLinkCallback(self, result, error=False, *args, **kwargs):
-        if error:
-            log.warning("Error while updating link: {}".format(result["message"]))
-            return
-        self._parseResponse(result)
-
-    def _updateLabels(self):
-        for node in self._nodes:
-            if node["node_id"] == self._source_node.node_id() and node["adapter_number"] == self._source_port.adapterNumber() and node["port_number"] == self._source_port.portNumber():
-                self._updateLabel(self._source_label, node["label"])
-            elif node["node_id"] == self._destination_node.node_id() and node["adapter_number"] == self._destination_port.adapterNumber() and node["port_number"] == self._destination_port.portNumber():
-                self._updateLabel(self._destination_label, node["label"])
+                # request the UDP info for each node
+                source_node.allocateUDPPort(self._source_port.id())
+                destination_node.allocateUDPPort(self._destination_port.id())
+            elif source_port.defaultNio() == NIOVMNET:
+                assert destination_port.defaultNio() == NIOVMNET
+                source_node.allocate_vmnet_nio_signal.connect(self.VMnetInterfaceAllocatedSlot)
+                source_node.allocateVMnetInterface(self._source_port.id())
             else:
-                raise NotImplementedError
-
-    def _updateLabel(self, label, label_data):
-        if not label or sip.isdeleted(label):
-            return
-        if "text" in label_data:
-            label.setPlainText(label_data["text"])
-        if "x" in label_data and "y" in label_data:
-            label.setPos(label_data["x"], label_data["y"])
-        if "style" in label_data:
-            label.setStyle(label_data["style"])
-        if "rotation" in label_data:
-            label.setRotation(label_data["rotation"])
-
-    def _prepareParams(self):
-        body = {
-            "nodes": [
-                {
-                    "node_id": self._source_node.node_id(),
-                    "adapter_number": self._source_port.adapterNumber(),
-                    "port_number": self._source_port.portNumber(),
-                },
-                {
-                    "node_id": self._destination_node.node_id(),
-                    "adapter_number": self._destination_port.adapterNumber(),
-                    "port_number": self._destination_port.portNumber()
-                }
-            ],
-            "filters": self._filters,
-            "link_style": self._link_style,
-            "suspend": self._suspend
-        }
-        if self._source_port.label():
-            body["nodes"][0]["label"] = self._source_port.label().dump()
-        if self._destination_port.label():
-            body["nodes"][1]["label"] = self._destination_port.label().dump()
-        return body
-
-    def _linkCreatedCallback(self, result, error=False, **kwargs):
-        if error:
-            log.warning("Error while creating link: {}".format(result["message"]))
-            self.deleteLink(skip_controller=True)
-            return
-
-        self._initialized = True
-
-        # let the GUI know about this link has been created
-        self.add_link_signal.emit(self._id)
-        self._source_port.setLinkId(self._id)
-        self._source_port.setLink(self)
-        self._source_port.setDestinationNode(self._destination_node)
-        self._source_port.setDestinationPort(self._destination_port)
-        self._destination_port.setLinkId(self._id)
-        self._destination_port.setLink(self)
-        self._destination_port.setDestinationNode(self._source_node)
-        self._destination_port.setDestinationPort(self._source_port)
-
-        self._link_id = result["link_id"]
-        self._parseResponse(result)
-
-    def link_id(self):
-        return self._link_id
-
-    def deleting(self):
-        """
-        Is the link being deleted
-        """
-        return self._deleting
-
-    def setDeleting(self):
-        """
-        Mark this link as being deleted
-        """
-
-        self._deleting = True
-
-    def capturing(self):
-        """
-        Is a capture running on the link?
-        """
-        return self._capturing
-
-    def capture_file_path(self):
-        """
-        Path of the capture file
-        """
-        return self._capture_file_path
-
-    def project(self):
-        return self._source_node.project()
+                raise NotImplementedError()
+        else:
+            # handle stub connections (to a cloud for instance).
+            if not source_port.isStub() and destination_port.isStub():
+                source_node.nio_signal.connect(self.newNIOSlot)
+                self._source_nio = self._destination_port.defaultNio()
+                self._source_node.nio_cancel_signal.connect(self.cancelNIOSlot)
+                self._source_node.addNIO(self._source_port, self._source_nio)
+            elif not destination_port.isStub() and source_port.isStub():
+                destination_node.nio_signal.connect(self.newNIOSlot)
+                self._destination_nio = self._source_port.defaultNio()
+                self._destination_node.nio_cancel_signal.connect(self.cancelNIOSlot)
+                self._destination_node.addNIO(self._destination_port, self._destination_nio)
+            else:
+                log.error("both ports are stub!")
 
     @classmethod
     def reset(cls):
@@ -299,123 +125,34 @@ class Link(QtCore.QObject):
 
     def __str__(self):
 
-        description = "Link from {} port {} to {} port {}".format(self._source_node.name(),
-                                                                  self._source_port.name(),
-                                                                  self._destination_node.name(),
-                                                                  self._destination_port.name())
+        return "Link from {} port {} to {} port {}".format(self._source_node.name(),
+                                                           self._source_port.name(),
+                                                           self._destination_node.name(),
+                                                           self._destination_port.name())
 
-        if self.capturing():
-            description += "\nPacket capture is active"
-
-        for filter_type in self._filters.keys():
-            description += "\nPacket filter '{}' is active".format(filter_type)
-
-        return description
-
-    def capture_file_name(self):
-        """
-        :returns: File name for a capture on this link
-        """
-        capture_file_name = "{}_{}_to_{}_{}".format(
-            self._source_node.name(),
-            self._source_port.name(),
-            self._destination_node.name(),
-            self._destination_port.name())
-        return re.sub(r"[^0-9A-Za-z_-]", "", capture_file_name)
-
-    def deleteLink(self, skip_controller=False):
+    def deleteLink(self):
         """
         Deletes this link.
         """
 
-        log.debug("deleting link from {} {} to {} {}".format(self._source_node.name(),
-                                                             self._source_port.name(),
-                                                             self._destination_node.name(),
-                                                             self._destination_port.name()))
-
-        if skip_controller:
-            self._linkDeletedCallback({})
-        else:
-            self.setDeleting()
-            Controller.instance().delete("/projects/{project_id}/links/{link_id}".format(project_id=self.project().id(),
-                                                                                         link_id=self._link_id),
-                                                                                         self._linkDeletedCallback)
-
-    def _linkDeletedCallback(self, result, error=False, **kwargs):
-        """
-        Called after the link is remove from the topology
-        """
-        if error:
-            log.error("Error while deleting link: {}".format(result["message"]))
-            return
+        log.info("deleting link from {} {} to {} {}".format(self._source_node.name(),
+                                                            self._source_port.name(),
+                                                            self._destination_node.name(),
+                                                            self._destination_port.name()))
 
+        # delete the NIOs on both source and destination nodes
+        if self._source_port.nio():
+            self._source_node.deleteNIO(self._source_port)
         self._source_port.setFree()
-        self._source_node.deleteLink(self)
         self._source_node.updated_signal.emit()
+        if self._destination_port.nio():
+            self._destination_node.deleteNIO(self._destination_port)
         self._destination_port.setFree()
-        self._destination_node.deleteLink(self)
         self._destination_node.updated_signal.emit()
 
         # let the GUI know about this link has been deleted
         self.delete_link_signal.emit(self._id)
 
-    def startCapture(self, data_link_type, capture_file_name):
-        data = {
-            "capture_file_name": capture_file_name,
-            "data_link_type": data_link_type
-        }
-        Controller.instance().post("/projects/{project_id}/links/{link_id}/start_capture".format(project_id=self.project().id(), link_id=self._link_id),
-                                   self._startCaptureCallback,
-                                   body=data)
-
-    def _startCaptureCallback(self, result, error=False, **kwargs):
-        if error:
-            log.error("Error while starting capture on link {}: {}".format(self._link_id, result["message"]))
-            return
-
-    def _downloadPcapProgress(self, content, server=None, context={}, **kwargs):
-        """
-        Called for each part of the file of the PCAP
-        """
-
-        if not self._capture_file_path:
-            return
-        self._capture_file.write(content)
-        self._capture_file.flush()
-
-    def stopCapture(self):
-
-        if Controller.instance().isRemote() or (self._capture_compute_id and self._capture_compute_id != "local"):
-            if self._capture_file:
-                self._capture_file.close()
-                self._capture_file = None
-            # if self._capture_file_path and os.path.exists(self._capture_file_path):
-            #     try:
-            #         os.remove(self._capture_file_path)
-            #     except OSError as e:
-            #         log.error("Cannot remove file {}: {}".format(self._capture_file_path, e))
-        self._capture_file_path = None
-        Controller.instance().post("/projects/{project_id}/links/{link_id}/stop_capture".format(project_id=self.project().id(),
-                                                                                                link_id=self._link_id),
-                                                                                                self._stopCaptureCallback)
-
-
-    def _stopCaptureCallback(self, result, error=False, **kwargs):
-        if error:
-            log.error("Error while stopping capture on link {}: {}".format(self._link_id, result["message"]))
-            return
-        log.debug("Has successfully stopped capturing packets on link {}".format(self._link_id))
-
-    def get(self, path, callback, **kwargs):
-        """
-        HTTP Get from a link
-        """
-        Controller.instance().get("/projects/{project_id}/links/{link_id}{path}".format(project_id=self.project().id(),
-                                                                                        link_id=self._link_id,
-                                                                                        path=path),
-                                  callback,
-                                  **kwargs)
-
     def id(self):
         """
         Returns this link identifier.
@@ -461,30 +198,217 @@ class Link(QtCore.QObject):
 
         return self._destination_port
 
-    def getNodePort(self, node):
+    def UDPPortAllocatedSlot(self, node_id, port_id, lport):
         """
-        Search the port in the link corresponding to this node
+        Slot to receive events from Node instances
+        when a UDP port has been allocated in order to create a NIO UDP.
 
-        :returns: Node instance
+        :param node_id: node identifier
+        :param port_id: port identifier
+        :param lport: local UDP port
         """
-        if self._destination_node == node:
-            return self._destination_port
-        return self._source_port
+        if not self:
+            return
 
-    def filters(self):
-        """
-        :returns: List the filters active on the node
-        """
-        return self._filters
+        # check that the node is connected to this link as a source
+        if self._source_node and node_id == self._source_node.id() and port_id == self._source_port.id():
+            laddr = self._source_node.server().host()
+            self._source_udp = (lport, laddr)
+            # disconnect the signal has we don't expect new source UDP info for this link.
+            self._source_node.allocate_udp_nio_signal.disconnect(self.UDPPortAllocatedSlot)
 
-    def setFilters(self, filters):
-        """
-        :params filters: List of filters
-        """
-        self._filters = filters
+            log.debug("{} has allocated UDP port {} for host {}".format(self._source_node.name(),
+                                                                        lport,
+                                                                        laddr))
 
-    def setLinkStyle(self, link_style):
+        # check that the node is connected to this link as a destination
+        elif self._destination_node and node_id == self._destination_node.id() and port_id == self._destination_port.id():
+            laddr = self._destination_node.server().host()
+            self._destination_udp = (lport, laddr)
+            # disconnect the signal has we don't expect new source UDP info for this link.
+            self._destination_node.allocate_udp_nio_signal.disconnect(self.UDPPortAllocatedSlot)
+
+            log.debug("{} has allocated UDP port {} for host {}".format(self._destination_node.name(),
+                                                                        lport,
+                                                                        laddr))
+
+        if self._source_udp and self._destination_udp:
+            # we got UDP info from both source and destination nodes
+            # meaning we can proceed with the creation of UDP NIOs
+            lport, laddr = self._source_udp
+            rport, raddr = self._destination_udp
+
+            self._source_nio = NIOUDP(lport, raddr, rport)
+            self._destination_nio = NIOUDP(rport, laddr, lport)
+
+            self._source_udp = None
+            self._destination_udp = None
+
+            log.debug("creating UDP tunnel from {}:{} to {}:{} ".format(laddr, lport, raddr, rport))
+
+            # add the UDP NIOs to the nodes
+            self._source_node.nio_cancel_signal.connect(self.cancelNIOSlot)
+            self._source_node.addNIO(self._source_port, self._source_nio)
+            self._destination_node.nio_cancel_signal.connect(self.cancelNIOSlot)
+            self._destination_node.addNIO(self._destination_port, self._destination_nio)
+
+    def VMnetInterfaceAllocatedSlot(self, node_id, port_id, vmnet):
         """
-        :params _link_style: Set link style attributes
+        Slot to receive events from Node instances
+        when a VMnet interface has been allocated in order to create a NIO VMNET.
+
+        :param node_id: node identifier
+        :param port_id: port identifier
+        :param vmnet: vmnet interface name
         """
-        self._link_style = link_style
+
+        # check that the node is connected to this link as a source
+        # only the source is used to request the server for a vmnet interface
+        # and then allocate a NIO VMNET to both the source and destination
+        if node_id == self._source_node.id() and port_id == self._source_port.id():
+            self._source_node.allocate_vmnet_nio_signal.disconnect(self.VMnetInterfaceAllocatedSlot)
+            self._source_nio = NIOVMNET(vmnet)
+            self._destination_nio = NIOVMNET(vmnet)
+
+            # add the VMnet NIOs to the nodes
+            self._source_node.nio_cancel_signal.connect(self.cancelNIOSlot)
+            self._source_node.addNIO(self._source_port, self._source_nio)
+            self._destination_node.nio_cancel_signal.connect(self.cancelNIOSlot)
+            self._destination_node.addNIO(self._destination_port, self._destination_nio)
+
+    def newNIOSlot(self, node_id, port_id):
+        """
+        Slot to receive events from Node instances
+        when a NIO has been created on the server
+        and are active.
+
+        :param node_id: node identifier
+        :param port_id: port identifier
+        """
+
+        # in very rare cases link is already deleted
+        if self is None:
+            return
+
+        # check that the node is connected to this link as a source
+        if node_id == self._source_node.id() and port_id == self._source_port.id():
+            self._source_nio_active = True
+            # disconnect the signal has we don't expect new source NIO for this link.
+            self._source_node.nio_signal.disconnect(self.newNIOSlot)
+
+        # check that the node is connected to this link as a destination
+        elif node_id == self._destination_node.id() and port_id == self._destination_port.id():
+            self._destination_nio_active = True
+            # disconnect the signal has we don't expect new destination NIO for this link.
+            self._destination_node.nio_signal.disconnect(self.newNIOSlot)
+
+        if not self._stub and self._source_nio_active and self._destination_nio_active:
+            # both NIOs are active now.
+            self._addToSourcePort(self._source_nio)
+            self._addToDestinationPort(self._destination_nio)
+
+            self._source_node.nio_cancel_signal.disconnect(self.cancelNIOSlot)
+            self._destination_node.nio_cancel_signal.disconnect(self.cancelNIOSlot)
+            self._source_nio_active = False
+            self._destination_nio_active = False
+
+            # let the GUI know about this link has been created
+            self.add_link_signal.emit(self._id)
+        elif self._stub and self._source_nio_active:
+            self._addToSourcePort(self._source_nio)
+            # add the NIO to destination to show the port is not free.
+            self._addToDestinationPort(self._source_nio)
+            self._source_nio_active = False
+            self._source_node.nio_cancel_signal.disconnect(self.cancelNIOSlot)
+            self.add_link_signal.emit(self._id)
+        elif self._stub and self._destination_nio_active:
+            # add the NIO to source to show the port is not free.
+            self._addToSourcePort(self._destination_nio)
+            self._addToDestinationPort(self._destination_nio)
+            self._destination_nio_active = False
+            self._destination_node.nio_cancel_signal.disconnect(self.cancelNIOSlot)
+            self.add_link_signal.emit(self._id)
+
+    def _addToSourcePort(self, nio):
+        """
+        Adds a NIO, a link id and a description to the source port.
+
+        :param nio: NIO instance
+        """
+
+        self._source_port.setNio(nio)
+        self._source_port.setLinkId(self._id)
+        self._source_port.setDestinationNode(self._destination_node)
+        self._source_port.setDestinationPort(self._destination_port)
+
+        log.debug("{} attached to {} on port {}".format(nio,
+                                                        self._source_node.name(),
+                                                        self._source_port.name()))
+
+    def _addToDestinationPort(self, nio):
+        """
+        Adds a NIO, a link id and a description to the destination port.
+
+        :param nio: NIO instance
+        """
+
+        self._destination_port.setNio(nio)
+        self._destination_port.setLinkId(self._id)
+        self._destination_port.setDestinationNode(self._source_node)
+        self._destination_port.setDestinationPort(self._source_port)
+
+        log.debug("{} attached to {} on port {}".format(nio,
+                                                        self._destination_node.name(),
+                                                        self._destination_port.name()))
+
+    def cancelNIOSlot(self, node_id):
+        """
+        Slot to receive events from Node instances
+        when a NIO has been canceled because of an
+        error returned by the server.
+
+        :param node_id: node identifier
+        """
+
+        if not self._stub:
+            try:
+                # the destination node has canceled its NIO allocation
+                self._destination_node.nio_signal.disconnect(self.newNIOSlot)
+            except TypeError:
+                # ignore TypeError: 'method' object is not connected
+                pass
+
+            try:
+                # the source node has canceled its NIO allocation
+                self._source_node.nio_signal.disconnect(self.newNIOSlot)
+            except TypeError:
+                # ignore TypeError: 'method' object is not connected
+                pass
+
+            self._source_node.nio_cancel_signal.disconnect(self.cancelNIOSlot)
+            self._destination_node.nio_cancel_signal.disconnect(self.cancelNIOSlot)
+        else:
+            if self._source_node.id() == node_id:
+                self._source_node.nio_signal.disconnect(self.newNIOSlot)
+                self._source_node.nio_cancel_signal.disconnect(self.cancelNIOSlot)
+            else:
+                self._destination_node.nio_signal.disconnect(self.newNIOSlot)
+                self._destination_node.nio_cancel_signal.disconnect(self.cancelNIOSlot)
+
+        self._source_nio_active = False
+        self._destination_nio_active = False
+        self.deleteLink()
+
+    def dump(self):
+        """
+        Returns a representation of this link.
+
+        :returns: dictionary
+        """
+
+        return {"id": self.id(),
+                "description": str(self),
+                "source_node_id": self._source_node.id(),
+                "source_port_id": self._source_port.id(),
+                "destination_node_id": self._destination_node.id(),
+                "destination_port_id": self._destination_port.id()}

gns3/local_config.py

@@ -24,10 +24,8 @@ import copy
 import psutil
 
 from .qt import QtCore, QtWidgets
-from .version import __version__, __version_info__
+from .version import __version__
 from .utils import parse_version
-from .local_server_config import LocalServerConfig
-from .settings import LOCAL_SERVER_SETTINGS
 
 import logging
 log = logging.getLogger(__name__)
@@ -42,31 +40,22 @@ class LocalConfig(QtCore.QObject):
     config_changed_signal = QtCore.Signal()
 
     def __init__(self, config_file=None):
-        """
-        :param config_file: Path to the config file (override all other config, useful for tests)
-        """
 
         super().__init__()
-        self._profile = None
-        self._config_file = config_file
-        self._migrateOldConfigPath()
-        self._resetLoadConfig()
-
-    def _resetLoadConfig(self):
-        """
-        Reload the config from scratch everything is clean
-
-        """
         self._settings = {}
         self._last_config_changed = None
+
         if sys.platform.startswith("win"):
             filename = "gns3_gui.ini"
         else:
             filename = "gns3_gui.conf"
 
+        self._migrateOldConfigPath()
+
         appname = "GNS3"
 
         if sys.platform.startswith("win"):
+
             # On windows, the system wide configuration file location is %COMMON_APPDATA%/GNS3/gns3_gui.conf
             common_appdata = os.path.expandvars("%COMMON_APPDATA%")
             system_wide_config_file = os.path.join(common_appdata, appname, filename)
@@ -74,8 +63,10 @@ class LocalConfig(QtCore.QObject):
             # On UNIX-like platforms, the system wide configuration file location is /etc/xdg/GNS3/gns3_gui.conf
             system_wide_config_file = os.path.join("/etc/xdg", appname, filename)
 
-        if not self._config_file:
-            self._config_file = os.path.join(self.configDirectory(), filename)
+        if config_file:
+            self._config_file = config_file
+        else:
+            self._config_file = os.path.join(LocalConfig.configDirectory(), filename)
 
         # First load system wide settings
         if os.path.exists(system_wide_config_file):
@@ -89,30 +80,8 @@ class LocalConfig(QtCore.QObject):
             try:
                 # create the config file if it doesn't exist
                 os.makedirs(os.path.dirname(self._config_file), exist_ok=True)
-
-                if sys.platform.startswith("win"):
-                    old_config_path = os.path.join(os.path.expandvars("%APPDATA%"), "GNS3", filename)
-                else:
-                    xgd_config_var = "$XDG_CONFIG_HOME"
-                    xdg_config_res = os.path.expandvars(xgd_config_var)
-                    if xdg_config_res  != xgd_config_var:
-                        old_config_path = os.path.join(xdg_config_res, "GNS3", filename)
-                    else:
-                        old_config_path = os.path.join(os.path.expanduser("~"), ".config", "GNS3", filename)
-
-                # TODO: migrate versioned config file from a previous version of GNS3 (for instance 2.2 -> 2.3) + support profiles
-                if os.path.exists(old_config_path):
-                    # migrate post version 2.2.0 configuration file
-                    shutil.copyfile(old_config_path, self._config_file)
-                    # reset the local server path and ubridge path
-                    settings = LocalServerConfig.instance().loadSettings("Server", LOCAL_SERVER_SETTINGS)
-                    settings["path"] = ""
-                    settings["ubridge_path"] = ""
-                    LocalServerConfig.instance().saveSettings("Server", settings)
-                else:
-                    # create a new config
-                    with open(self._config_file, "w", encoding="utf-8") as f:
-                        json.dump({"version": __version__, "type": "settings"}, f)
+                with open(self._config_file, "w", encoding="utf-8") as f:
+                    json.dump({"version": __version__, "type": "settings"}, f)
             except OSError as e:
                 log.error("Could not create the config file {}: {}".format(self._config_file, e))
 
@@ -120,54 +89,21 @@ class LocalConfig(QtCore.QObject):
         # overwrite system wide settings with user specific ones
         self._settings.update(user_settings)
         self._migrateOldConfig()
-        self.writeConfig()
+        self._writeConfig()
 
-    def profile(self):
-        """
-        :returns: Current settings profile
-        """
-        return self._profile
-
-    def setProfile(self, profile):
-        previous_profile = self._profile
-        if profile == "default":
-            self._profile = None
-        else:
-            self._profile = profile
-        if previous_profile != self._profile:
-            self._config_file = None
-            self._resetLoadConfig()
-
-    def configDirectory(self):
+    @staticmethod
+    def configDirectory():
         """
         Get the configuration directory
         """
-
-        version = "{}.{}".format(__version_info__[0], __version_info__[1])
         if sys.platform.startswith("win"):
             appdata = os.path.expandvars("%APPDATA%")
-            path = os.path.join(appdata, "GNS3", version)
+            path = os.path.join(appdata, "GNS3")
         else:
-            xgd_config_var = "$XDG_CONFIG_HOME"
-            xdg_config_res = os.path.expandvars(xgd_config_var)
-            if xdg_config_res != xgd_config_var:
-                path = os.path.join(xdg_config_res, "GNS3", version)
-            else:
-                home = os.path.expanduser("~")
-                path = os.path.join(home, ".config", "GNS3", version)
-
-        if self._profile is not None:
-            path = os.path.join(path, "profiles", self._profile)
-
+            home = os.path.expanduser("~")
+            path = os.path.join(home, ".config", "GNS3")
         return os.path.normpath(path)
 
-    def runAsRootPath(self):
-        """
-        Gets run as root filename
-        :return: string
-        """
-        return os.path.join(self.configDirectory(), "run_as_root")
-
     def _migrateOldConfigPath(self):
         """
         Migrate pre 1.4 config path
@@ -176,18 +112,17 @@ class LocalConfig(QtCore.QObject):
         # In < 1.4 on Mac the config was in a gns3.net directory
         # We have move to same location as Linux
         if sys.platform.startswith("darwin"):
-            version = "{}.{}".format(__version_info__[0], __version_info__[1])
             old_path = os.path.join(os.path.expanduser("~"), ".config", "gns3.net")
-            new_path = os.path.join(os.path.expanduser("~"), ".config", "GNS3", version)
+            new_path = os.path.join(os.path.expanduser("~"), ".config", "GNS3")
             if os.path.exists(old_path) and not os.path.exists(new_path):
                 try:
                     shutil.copytree(old_path, new_path)
                 except OSError as e:
-                    log.error("Can't copy the old config: %s", str(e))
+                    print("Can't copy the old config: %s", str(e))
 
     def _migrateOldConfig(self):
         """
-        Migrate config from a previous version.
+        Migrate pre 1.4 config
         """
 
         # Display an error if settings come from a more recent version of GNS3
@@ -196,30 +131,27 @@ class LocalConfig(QtCore.QObject):
         if "version" in self._settings:
             if parse_version(self._settings["version"])[:2] > parse_version(__version__)[:2]:
                 app = QtWidgets.QApplication(sys.argv)  # We need to create an application because settings are loaded before Qt init
-                error_message = "Settings are for version {} of GNS3. It is not possible to use a previous version of GNS3 without risking losing data. Delete the settings in '{}' to start GNS3".format(self._settings["version"], self.configDirectory())
-                QtWidgets.QMessageBox.critical(False, "Version error", error_message)
+                QtWidgets.QMessageBox.critical(None, "Version error", "Your settings are for version {} of GNS3. You cannot use a previous version of GNS3 without risking losing data.".format(self._settings["version"]))
                 # Exit immediately not clean but we want to avoid any side effect that could corrupt the file
-                QtCore.QTimer.singleShot(0, app.quit)
-                app.exec()
                 sys.exit(1)
 
         if "version" not in self._settings or parse_version(self._settings["version"]) < parse_version("1.4.0alpha1"):
 
-             servers = self._settings.get("Servers", {})
+            servers = self._settings.get("Servers", {})
 
-             if "LocalServer" in self._settings:
+            if "LocalServer" in self._settings:
                 servers["local_server"] = copy.copy(self._settings["LocalServer"])
 
-                 # We migrate the server binary for OSX due to the change from py2app to CX freeze
+                # We migrate the server binary for OSX due to the change from py2app to CX freeze
                 if servers["local_server"]["path"] == "/Applications/GNS3.app/Contents/Resources/server/Contents/MacOS/gns3server":
-                    servers["local_server"]["path"] = "gns3server"
+                    servers["local_server"]["path"] = "/Applications/GNS3.app/Contents/MacOS/gns3server"
 
-             if "RemoteServers" in self._settings:
+            if "RemoteServers" in self._settings:
                 servers["remote_servers"] = copy.copy(self._settings["RemoteServers"])
 
-             self._settings["Servers"] = servers
+            self._settings["Servers"] = servers
 
-             if "GUI" in self._settings:
+            if "GUI" in self._settings:
                 main_window = self._settings.get("MainWindow", {})
                 main_window["hide_getting_started_dialog"] = self._settings["GUI"].get("hide_getting_started_dialog", False)
                 self._settings["MainWindow"] = main_window
@@ -229,38 +161,15 @@ class LocalConfig(QtCore.QObject):
                 from .settings import PRECONFIGURED_TELNET_CONSOLE_COMMANDS, DEFAULT_TELNET_CONSOLE_COMMAND
 
                 if "MainWindow" in self._settings:
-                    if self._settings["MainWindow"].get("telnet_console_command") not in PRECONFIGURED_TELNET_CONSOLE_COMMANDS.values():
+                    if self._settings["MainWindow"]["telnet_console_command"] not in PRECONFIGURED_TELNET_CONSOLE_COMMANDS.values():
                         self._settings["MainWindow"]["telnet_console_command"] = DEFAULT_TELNET_CONSOLE_COMMAND
 
-         # Migrate 1.X to 2.0
-        if "version" not in self._settings or parse_version(self._settings["version"]) < parse_version("2.0.0"):
-            if "Qemu" in self._settings:
-                # The internet VM is replaced by the nat Node
-                # we remove it from the list of available VM
-                vms = []
-                for vm in self._settings["Qemu"].get("vms", []):
-                    if vm.get("hda_disk_image") != "core-linux-6.4-internet-0.1.img":
-                        vms.append(vm)
-                self._settings["Qemu"]["vms"] = vms
-
-         # Starting with 2.0.0dev5 IOU licence is stored in the settings
-        if "version" not in self._settings or parse_version(self._settings["version"]) < parse_version("2.0.0"):
-            if "IOU" in self._settings and "iourc_path" in self._settings["IOU"] and "iourc_content" not in self._settings["IOU"]:
-                try:
-                    with open(self._settings["IOU"]["iourc_path"], "r", encoding="utf-8") as f:
-                        self._settings["IOU"]["iourc_content"] = f.read().replace("\r\n", "\n")
-                        del self._settings["IOU"]["iourc_path"]
-                except OSError as e:
-                    log.warning("Can't import IOU licence {}: {}".format(self._settings["IOU"]["iourc_path"], str(e)))
-                except UnicodeDecodeError as e:
-                    log.warning("Non ascii characters in iourc file {}, please remove them: {}".format(self._settings["IOU"]["iourc_path"], str(e)))
-
     def _readConfig(self, config_path):
         """
         Read the configuration file.
         """
 
-        log.debug("Load config from %s", config_path)
+        log.info("Load config from %s", config_path)
         try:
             with open(config_path, "r", encoding="utf-8") as f:
                 self._last_config_changed = os.stat(config_path).st_mtime
@@ -276,7 +185,7 @@ class LocalConfig(QtCore.QObject):
 
         return dict()
 
-    def writeConfig(self):
+    def _writeConfig(self):
         """
         Write the configuration file.
         """
@@ -287,7 +196,7 @@ class LocalConfig(QtCore.QObject):
             with open(temporary, "w", encoding="utf-8") as f:
                 json.dump(self._settings, f, sort_keys=True, indent=4)
             shutil.move(temporary, self._config_file)
-            log.debug("Configuration save to %s", self._config_file)
+            log.info("Configuration save to %s", self._config_file)
             self._last_config_changed = os.stat(self._config_file).st_mtime
         except (ValueError, OSError) as e:
             log.error("Could not write the config file {}: {}".format(self._config_file, e))
@@ -296,7 +205,7 @@ class LocalConfig(QtCore.QObject):
 
         try:
             if self._last_config_changed and self._last_config_changed < os.stat(self._config_file).st_mtime:
-                log.debug("Client config has changed, reloading it...")
+                log.info("Client config has changed, reloading it...")
                 self._readConfig(self._config_file)
                 self.config_changed_signal.emit()
         except OSError as e:
@@ -319,7 +228,7 @@ class LocalConfig(QtCore.QObject):
         """
 
         self._config_file = config_file
-        self._resetLoadConfig()
+        self._readConfig(self._config_file)
 
     def settings(self):
         """
@@ -339,8 +248,7 @@ class LocalConfig(QtCore.QObject):
 
         if self._settings != settings:
             self._settings.update(settings)
-            self.writeConfig()
-            self.config_changed_signal.emit()
+            self._writeConfig()
 
     def loadSectionSettings(self, section, default_settings):
         """
@@ -374,8 +282,9 @@ class LocalConfig(QtCore.QObject):
         self._settings[section] = settings
 
         if changed:
-            log.debug("Section %s has missing default values. Adding keys %s Saving configuration", section, ','.join(set(default_settings.keys()) - set(settings.keys())))
-            self.writeConfig()
+            log.info("Section %s has missing default values. Adding keys %s Saving configuration", section, ','.join(set(default_settings.keys()) - set(settings.keys())))
+            self._writeConfig()
+
         return copy.deepcopy(settings)
 
     def saveSectionSettings(self, section, settings):
@@ -391,8 +300,8 @@ class LocalConfig(QtCore.QObject):
 
         if self._settings[section] != settings:
             self._settings[section].update(copy.deepcopy(settings))
-            log.debug("Section %s has changed. Saving configuration", section)
-            self.writeConfig()
+            log.info("Section %s has changed. Saving configuration", section)
+            self._writeConfig()
         else:
             log.debug("Section %s has not changed. Skip saving configuration", section)
 
@@ -404,66 +313,8 @@ class LocalConfig(QtCore.QObject):
         from gns3.settings import GENERAL_SETTINGS
         return self.loadSectionSettings("MainWindow", GENERAL_SETTINGS)["experimental_features"]
 
-    def multiProfiles(self):
-        """
-        :returns: Boolean. True if multi_profiles is enabled
-        """
-
-        from gns3.settings import GENERAL_SETTINGS
-        return self.loadSectionSettings("MainWindow", GENERAL_SETTINGS)["multi_profiles"]
-
-    def setMultiProfiles(self, value):
-        from gns3.settings import GENERAL_SETTINGS
-        settings = self.loadSectionSettings("MainWindow", GENERAL_SETTINGS)
-        settings["multi_profiles"] = value
-        self.saveSectionSettings("MainWindow", settings)
-
-    def directFileUpload(self):
-        """
-        :returns: Boolean. True if direct_file_upload is enabled
-        """
-
-        from gns3.settings import GENERAL_SETTINGS
-        return self.loadSectionSettings("MainWindow", GENERAL_SETTINGS)["direct_file_upload"]
-
-    def setDirectFileUpload(self, value):
-        from gns3.settings import GENERAL_SETTINGS
-        settings = self.loadSectionSettings("MainWindow", GENERAL_SETTINGS)
-        settings["direct_file_upload"] = value
-        self.saveSectionSettings("MainWindow", settings)
-
-    def showInterfaceLabelsOnNewProject(self):
-        """
-        :returns: Boolean. True if show_interface_labels_on_new_project is enabled
-        """
-
-        from gns3.settings import GRAPHICS_VIEW_SETTINGS
-        return self.loadSectionSettings("GraphicsView", GRAPHICS_VIEW_SETTINGS).get("show_interface_labels_on_new_project", False)
-
-    def setShowInterfaceLabelsOnNewProject(self, value):
-        from gns3.settings import GRAPHICS_VIEW_SETTINGS
-        settings = self.loadSectionSettings("GraphicsView", GRAPHICS_VIEW_SETTINGS)
-        settings["show_interface_labels_on_new_project"] = value
-        self.saveSectionSettings("GraphicsView", settings)
-
-    def showGridOnNewProject(self):
-        """
-        :returns: Boolean. True if show_grid_on_new_project is enabled
-        """
-
-        from gns3.settings import GRAPHICS_VIEW_SETTINGS
-        return self.loadSectionSettings("GraphicsView", GRAPHICS_VIEW_SETTINGS).get("show_grid_on_new_project", False)
-
-    def snapToGridOnNewProject(self):
-        """
-        :returns: Boolean. True if snap_to_grid_on_new_project is enabled
-        """
-
-        from gns3.settings import GRAPHICS_VIEW_SETTINGS
-        return self.loadSectionSettings("GraphicsView", GRAPHICS_VIEW_SETTINGS).get("snap_to_grid_on_new_project", False)
-
     @staticmethod
-    def instance():
+    def instance(config_file=None):
         """
         Singleton to return only on instance of LocalConfig.
 
@@ -471,7 +322,7 @@ class LocalConfig(QtCore.QObject):
         """
 
         if not hasattr(LocalConfig, "_instance") or LocalConfig._instance is None:
-            LocalConfig._instance = LocalConfig()
+            LocalConfig._instance = LocalConfig(config_file=config_file)
         return LocalConfig._instance
 
     @staticmethod
@@ -481,16 +332,16 @@ class LocalConfig(QtCore.QObject):
         """
 
         my_pid = os.getpid()
-        pid_path = os.path.join(LocalConfig.instance().configDirectory(), "gns3_gui.pid")
+        pid_path = os.path.join(LocalConfig.configDirectory(), "gns3_gui.pid")
 
         if os.path.exists(pid_path):
             try:
-                with open(pid_path, encoding="utf-8") as f:
+                with open(pid_path) as f:
                     pid = int(f.read())
                     if pid != my_pid:
                         try:
                             process = psutil.Process(pid=pid)
-                            ps_name = process.name().lower()
+                            ps_name = process.name()
                         except (OSError, psutil.NoSuchProcess, psutil.AccessDenied):
                             pass
                         else:
@@ -500,17 +351,9 @@ class LocalConfig(QtCore.QObject):
                                     return False
                     else:
                         return True
-            except OSError as e:
+            except (OSError, ValueError) as e:
                 log.critical("Can't read pid file %s: %s", pid_path, str(e))
                 return False
-            except ValueError as e:
-                log.warning("Invalid data in pid file %s: %s", pid_path, str(e))
-                try:
-                    # try removing the file since it contains invalid data
-                    os.remove(pid_path)
-                except OSError:
-                    log.critical("Can't remove pid file %s", pid_path)
-                    return False
 
         try:
             with open(pid_path, 'w+') as f:

gns3/local_server.py

@@ -1,616 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright (C) 2016 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 os
-import sys
-import copy
-import stat
-import shlex
-import socket
-import shutil
-import random
-import string
-import struct
-import psutil
-import signal
-import subprocess
-
-
-from gns3.qt import QtWidgets, QtCore, qslot
-from gns3.settings import LOCAL_SERVER_SETTINGS, DEFAULT_LOCAL_SERVER_HOST
-from gns3.local_config import LocalConfig
-from gns3.local_server_config import LocalServerConfig
-from gns3.utils.wait_for_connection_worker import WaitForConnectionWorker
-from gns3.utils.progress_dialog import ProgressDialog
-from gns3.utils.sudo import sudo
-from gns3.http_client import HTTPClient
-from gns3.controller import Controller
-
-
-import logging
-log = logging.getLogger(__name__)
-
-
-class StopLocalServerWorker(QtCore.QObject):
-    """
-    Worker for displaying a progress dialog when closing
-    the server
-    """
-    # signals to update the progress dialog.
-    error = QtCore.Signal(str, bool)
-    finished = QtCore.Signal()
-    updated = QtCore.Signal(int)
-
-    def __init__(self, local_server_process):
-        super().__init__()
-        self._local_server_process = local_server_process
-        self._precision = 100  # In MS
-        self._remaining_trial = int(10 * (1000 / self._precision))
-
-    @qslot
-    def _callbackSlot(self, *params):
-        self._local_server_process.poll()
-        if self._local_server_process.returncode is None and self._remaining_trial > 0:
-            self._remaining_trial -= 1
-            QtCore.QTimer.singleShot(self._precision, self._callbackSlot)
-        else:
-            self.finished.emit()
-
-    def run(self):
-        QtCore.QTimer.singleShot(1000, self._callbackSlot)
-
-    def cancel(self):
-        return
-
-
-class LocalServer(QtCore.QObject):
-    """
-    Manage the local server process
-    """
-
-    def __init__(self, parent=None):
-        # Remember if the server was started by us or not
-        self._server_started_by_me = False
-        self._local_server_path = ""
-        self._local_server_process = None
-
-        super().__init__()
-        self._parent = parent
-        self._config_directory = LocalConfig.instance().configDirectory()
-        self._settings = {}
-        self.localServerSettings()
-        self._port = self._settings.get("port", 3080)
-        if not self._settings.get("auto_start", True):
-            if self._settings.get("host") is None:
-                self._http_client = HTTPClient(self._settings)
-                Controller.instance().setHttpClient(self._http_client)
-        else:
-            self._http_client = None
-
-        self._stopping = False
-        self._timer = QtCore.QTimer()
-        self._timer.setInterval(5000)
-        self._timer.timeout.connect(self._checkLocalServerRunningSlot)
-        self._timer.start()
-
-    def _pid_path(self):
-        """
-        :returns: Path of the PID file
-        """
-        return os.path.join(self._config_directory, "gns3_server.pid")
-
-    def parent(self):
-        """
-        Parent window
-        """
-        if self._parent is None:
-            from gns3.main_window import MainWindow
-            return MainWindow.instance()
-        return self._parent
-
-    def _checkWindowsService(self, service_name):
-
-        try:
-            import pywintypes
-            import win32service
-            import win32serviceutil
-        except ImportError as e:
-            log.error("Could not check if the {} service is running: {}".format(service_name, e))
-            return
-
-        try:
-            if win32serviceutil.QueryServiceStatus(service_name, None)[1] != win32service.SERVICE_RUNNING:
-                return False
-        except pywintypes.error as e:
-            if e.winerror == 1060:  # service is not installed
-                return False
-            else:
-                log.error("Could not check if the {} service is running: {}".format(service_name, e.strerror))
-
-        return True
-
-    def _checkUbridgePermissions(self):
-        """
-        Checks that uBridge can interact with network interfaces.
-        """
-
-        path = os.path.abspath(self._settings["ubridge_path"])
-
-        if not path or len(path) == 0 or not os.path.exists(path) or not os.path.isfile(path):
-            return False
-
-        if sys.platform.startswith("win"):
-            # do not check anything on Windows
-            return True
-
-        if os.geteuid() == 0:
-            # we are root, so we should have privileged access.
-            return True
-
-        request_setuid = False
-        if sys.platform.startswith("linux"):
-            # test if the executable has the CAP_NET_RAW capability (Linux only)
-            try:
-                # test the 2nd byte and check if the 13th bit (CAP_NET_RAW) is set
-                if "security.capability" not in os.listxattr(path) or not struct.unpack("<IIIII", os.getxattr(path, "security.capability"))[1] & 1 << 13:
-                    proceed = QtWidgets.QMessageBox.question(
-                        self.parent(),
-                        "uBridge",
-                        "uBridge requires CAP_NET_RAW capability to interact with network interfaces. Set the capability to uBridge? All users on the system will be able to read packet from the network interfaces.",
-                        QtWidgets.QMessageBox.StandardButton.Yes,
-                        QtWidgets.QMessageBox.StandardButton.No)
-                    if proceed == QtWidgets.QMessageBox.StandardButton.Yes:
-                        sudo(["setcap", "cap_net_admin,cap_net_raw=ep", path])
-            except AttributeError:
-                # Due to a Python bug, os.listxattr could be missing: https://github.com/GNS3/gns3-gui/issues/2010
-                log.warning("Could not determine if CAP_NET_RAW capability is set for uBridge (Python bug)")
-                return True
-            except OSError as e:
-                QtWidgets.QMessageBox.critical(self.parent(), "uBridge", "Can't set CAP_NET_RAW capability to uBridge {}: {}".format(path, str(e)))
-                request_setuid = True
-
-        if sys.platform.startswith("darwin") or request_setuid:
-            try:
-                if os.stat(path).st_uid != 0 or not os.stat(path).st_mode & stat.S_ISUID:
-                    proceed = QtWidgets.QMessageBox.question(
-                        self.parent(),
-                        "uBridge",
-                        "uBridge requires root permissions to interact with network interfaces. Set root permissions to uBridge? All admin users on the system will be able to read packet from the network interfaces.",
-                        QtWidgets.QMessageBox.StandardButton.Yes,
-                        QtWidgets.QMessageBox.StandardButton.No)
-                    if proceed == QtWidgets.QMessageBox.StandardButton.Yes:
-                        from gns3.utils.macos_ubridge_setuid import macos_ubridge_setuid
-                        if sys.platform.startswith("darwin") and hasattr(sys, "frozen"):
-                            macos_ubridge_setuid()
-                        else:
-                            sudo(["chown", "root:admin", path], ["chmod", "4750", path])
-            except OSError as e:
-                QtWidgets.QMessageBox.critical(self.parent(), "uBridge", "Can't set root permissions to uBridge {}: {}".format(path, str(e)))
-                return False
-        return True
-
-    def _passwordGenerate(self):
-        """
-        Generate a random password
-        """
-        return ''.join(random.choice(string.ascii_letters + string.digits) for _ in range(64))
-
-    def localServerSettings(self):
-        """
-        Returns the local server settings.
-
-        :returns: local server settings (dict)
-        """
-
-        settings = LocalServerConfig.instance().loadSettings("Server", LOCAL_SERVER_SETTINGS)
-        self._settings = copy.copy(settings)
-
-        # user & password
-        if settings["auth"] is True and not settings["user"].strip():
-            settings["user"] = "admin"
-            settings["password"] = self._passwordGenerate()
-
-        # local GNS3 server path
-        local_server_path = shutil.which(settings["path"].strip())
-        if local_server_path is None:
-            default_server_path = shutil.which("gns3server")
-            if default_server_path is not None:
-                settings["path"] = os.path.abspath(default_server_path)
-        else:
-            settings["path"] = os.path.abspath(local_server_path)
-
-        # uBridge path
-        ubridge_path = shutil.which(settings["ubridge_path"].strip())
-        if ubridge_path is None:
-            default_ubridge_path = shutil.which("ubridge")
-            if default_ubridge_path is not None:
-                settings["ubridge_path"] = os.path.abspath(default_ubridge_path)
-        else:
-            settings["ubridge_path"] = os.path.abspath(ubridge_path)
-
-        if self._settings != settings:
-            self.updateLocalServerSettings(settings)
-        return settings
-
-    def updateLocalServerSettings(self, new_settings):
-        """
-        Update the local server settings. Keep the key not in new_settings
-        """
-
-        if "host" in new_settings and new_settings["host"] is None:
-            new_settings["host"] = DEFAULT_LOCAL_SERVER_HOST
-        old_settings = copy.copy(self._settings)
-        if not self._settings:
-            self._settings = new_settings
-        else:
-            self._settings.update(new_settings)
-        self._port = self._settings["port"]
-        LocalServerConfig.instance().saveSettings("Server", self._settings)
-
-        # Settings have changed we need to restart the server
-        if old_settings != self._settings:
-            if self._settings["auto_start"]:
-                # We restart the local server only if we really need. Auth can be hot change
-                settings_require_restart = ('host', 'port', 'path')
-                need_restart = False
-                for s in settings_require_restart:
-                    if old_settings.get(s) != self._settings.get(s):
-                        need_restart = True
-
-                if need_restart:
-                    self.stopLocalServer(wait=True)
-
-                self.localServerAutoStartIfRequired()
-            # If the controller is remote:
-            else:
-                self.stopLocalServer(wait=True)
-
-            if self._settings.get("host") is None:
-                self._http_client = None
-            else:
-                self._http_client = HTTPClient(self._settings)
-            Controller.instance().setHttpClient(self._http_client)
-
-    def shouldLocalServerAutoStart(self):
-        """
-        Returns either the local server
-        is automatically started on startup.
-
-        :returns: boolean
-        """
-
-        return self._settings["auto_start"] and self._settings["host"] is not None
-
-    def localServerPath(self):
-        """
-        Returns the local server path.
-
-        :returns: path to local server program.
-        """
-
-        return self._settings["path"]
-
-    def _killAlreadyRunningServer(self):
-        """
-        Kill a running zombie server (started by a gui that no longer exists)
-        This will not kill server started by hand.
-        """
-        try:
-            if os.path.exists(self._pid_path()):
-                with open(self._pid_path()) as f:
-                    pid = int(f.read())
-                process = psutil.Process(pid=pid)
-                log.info("Kill already running server with PID %d", pid)
-                process.kill()
-        except (OSError, ValueError, psutil.NoSuchProcess, psutil.AccessDenied):
-            # Permission issue, or process no longer exists, or file is empty
-            return
-
-    def localServerAutoStartIfRequired(self):
-        """
-        Try to start the embedded gns3 server.
-        """
-
-        if not self.shouldLocalServerAutoStart():
-            self._http_client = HTTPClient(self._settings)
-            Controller.instance().setHttpClient(self._http_client)
-            return
-
-        if self.isLocalServerRunning() and self._server_started_by_me:
-            return True
-
-        # We check if two gui are not launched at the same time
-        # to avoid killing the server of the other GUI
-        if not LocalConfig.isMainGui():
-            log.info("Not the main GUI, will not auto start the server")
-            self._http_client = HTTPClient(self._settings)
-            Controller.instance().setHttpClient(self._http_client)
-            return True
-
-        if self.isLocalServerRunning():
-            log.debug("A local server already running on this host")
-            # Try to kill the server. The server can be still running after
-            # if the server was started by hand
-            self._killAlreadyRunningServer()
-
-        if not self.isLocalServerRunning():
-            if not self.initLocalServer():
-                QtWidgets.QMessageBox.critical(self.parent(), "Local server", "Could not start the local server process: {}".format(self._settings["path"]))
-                return False
-            if not self.startLocalServer():
-                QtWidgets.QMessageBox.critical(self.parent(), "Local server", "Could not start the local server process: {}".format(self._settings["path"]))
-                return False
-
-        if self.parent():
-            worker = WaitForConnectionWorker(self._settings["host"], self._port)
-            progress_dialog = ProgressDialog(worker,
-                                             "Local server",
-                                             "Connecting to server {} on port {}...".format(self._settings["host"], self._port),
-                                             "Cancel", busy=True, parent=self.parent())
-            progress_dialog.show()
-            if not progress_dialog.exec():
-                return False
-        self._server_started_by_me = True
-        self._http_client = HTTPClient(self._settings)
-        Controller.instance().setHttpClient(self._http_client)
-        return True
-
-    def initLocalServer(self):
-        """
-        Initialize the local server.
-        """
-
-        self._checkUbridgePermissions()
-
-        if sys.platform.startswith("win"):
-            import pywintypes
-            try:
-                if not self._checkWindowsService("npf") and not self._checkWindowsService("npcap"):
-                    log.warning("The NPF or NPCAP service is not installed, please install Winpcap or Npcap and reboot.")
-            except pywintypes.error as e:
-                log.warning("Could not check if the NPF or Npcap service is running: {}".format(e.strerror))
-
-        self._port = self._settings["port"]
-        # check the local server path
-        local_server_path = self.localServerPath()
-        if not local_server_path:
-            log.warning("No local server is configured")
-            return False
-        if not os.path.isfile(local_server_path):
-            QtWidgets.QMessageBox.critical(self.parent(), "Local server", "Could not find local server {}".format(local_server_path))
-            return False
-        elif not os.access(local_server_path, os.X_OK):
-            QtWidgets.QMessageBox.critical(self.parent(), "Local server", "{} is not an executable".format(local_server_path))
-            return False
-
-        try:
-            # check if the local address still exists
-            for res in socket.getaddrinfo(self._settings["host"], 0, socket.AF_UNSPEC, socket.SOCK_STREAM, 0, socket.AI_PASSIVE):
-                af, socktype, proto, _, sa = res
-                with socket.socket(af, socktype, proto) as sock:
-                    sock.bind(sa)
-                    break
-        except OSError as e:
-            QtWidgets.QMessageBox.critical(self.parent(), "Local server", "Could not bind with {}: {} (please check your host binding setting in the preferences)".format(self._settings["host"], e))
-            return False
-
-        try:
-            # check if the port is already taken
-            find_unused_port = False
-            for res in socket.getaddrinfo(self._settings["host"], self._port, socket.AF_UNSPEC, socket.SOCK_STREAM, 0, socket.AI_PASSIVE):
-                af, socktype, proto, _, sa = res
-                with socket.socket(af, socktype, proto) as sock:
-                    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-                    sock.bind(sa)
-                    break
-        except OSError as e:
-            log.warning("Could not use socket {}:{} {}".format(self._settings["host"], self._port, e))
-            find_unused_port = True
-
-        if find_unused_port:
-            # find an alternate port for the local server
-            old_port = self._port
-            try:
-                self._port = self._findUnusedLocalPort(self._settings["host"])
-            except OSError as e:
-                QtWidgets.QMessageBox.critical(self.parent(), "Local server", "Could not find an unused port for the local server: {}".format(e))
-                return False
-            log.warning("The server port {} is already in use, fallback to port {}".format(old_port, self._port))
-        return True
-
-    def _findUnusedLocalPort(self, host):
-        """
-        Find an unused port.
-
-        :param host: server hosts
-
-        :returns: port number
-        """
-
-        with socket.socket() as s:
-            s.bind((host, 0))
-            return s.getsockname()[1]
-
-    def startLocalServer(self):
-        """
-        Starts the local server process.
-        """
-
-        self._stopping = False
-        path = self.localServerPath()
-        command = '"{executable}" --local'.format(executable=path)
-
-        if LocalConfig.instance().profile():
-            command += " --profile {}".format(LocalConfig.instance().profile())
-
-        if self._settings["allow_console_from_anywhere"]:
-            # allow connections to console from remote addresses
-            command += " --allow"
-
-        if logging.getLogger().isEnabledFor(logging.DEBUG):
-            command += " --debug"
-
-        settings_dir = self._config_directory
-        if os.path.isdir(settings_dir):
-            # save server logging info to a file in the settings directory
-            logpath = os.path.join(settings_dir, "gns3_server.log")
-            if os.path.isfile(logpath):
-                # delete the previous log file
-                try:
-                    os.remove(logpath)
-                except FileNotFoundError:
-                    pass
-                except OSError as e:
-                    log.warning("could not delete server log file {}: {}".format(logpath, e))
-            command += ' --log="{}" --pid="{}"'.format(logpath, self._pid_path())
-
-        log.debug("Starting local server process with {}".format(command))
-        try:
-            if sys.platform.startswith("win"):
-                # use the string on Windows
-                self._local_server_process = subprocess.Popen(
-                    command,
-                    creationflags=subprocess.CREATE_NEW_PROCESS_GROUP,
-                    stderr=subprocess.PIPE,
-                    env=os.environ)
-            else:
-                # use arguments on other platforms
-                args = shlex.split(command)
-                self._local_server_process = subprocess.Popen(args, stderr=subprocess.PIPE, env=os.environ)
-        except (OSError, subprocess.SubprocessError) as e:
-            log.warning('Could not start local server "{}": {}'.format(command, e))
-            return False
-
-        log.debug("Local server process has started (PID={})".format(self._local_server_process.pid))
-        return True
-
-    def _checkLocalServerRunningSlot(self):
-        if self._local_server_process and not self._stopping:
-            if not self.localServerProcessIsRunning():
-                log.error("Local server process has stopped")
-                try:
-                    log.error(self._local_server_process.stderr.read().decode())
-                except (OSError, UnicodeDecodeError):
-                    pass
-                self._local_server_process = None
-
-    def localServerProcessIsRunning(self):
-        """
-        Returns either the local server is running.
-
-        :returns: boolean
-        """
-
-        try:
-            if self._local_server_process and self._local_server_process.poll() is None:
-                return True
-        except OSError:
-            pass
-        return False
-
-    def isLocalServerRunning(self):
-        """
-        Synchronous check if a server is already running on this host.
-
-        :returns: boolean
-        """
-
-        status, json_data = HTTPClient(self._settings).getSynchronous("GET", "/version")
-        if status == 401:  # Auth issue that need to be solved later
-            return True
-        elif json_data is None:
-            return False
-        elif status != 200:
-            return False
-        else:
-            version = json_data.get("version", None)
-            if version is None:
-                log.debug("Server is not a GNS3 server")
-                return False
-        return True
-
-    def stopLocalServer(self, wait=False):
-        """
-        Stops the local server.
-
-        :param wait: wait for the server to stop
-        """
-
-        if self.localServerProcessIsRunning():
-            self._stopping = True
-            log.debug("Stopping local server (PID={})".format(self._local_server_process.pid))
-            # local server is running, let's stop it
-            if self._http_client:
-                self._http_client.shutdown()
-            if wait:
-                worker = StopLocalServerWorker(self._local_server_process)
-                progress_dialog = ProgressDialog(worker, "Local server", "Waiting for the local server to stop...", None, busy=True, parent=self.parent())
-                progress_dialog.show()
-                progress_dialog.exec()
-                if self._local_server_process.returncode is None:
-                    self._killLocalServer()
-            self._server_started_by_me = False
-
-    def _killLocalServer(self):
-        # the local server couldn't be stopped with the normal procedure
-        try:
-            if sys.platform.startswith("win"):
-                self._local_server_process.send_signal(signal.CTRL_BREAK_EVENT)
-            else:
-                self._local_server_process.send_signal(signal.SIGINT)
-        # If the process is already dead we received a permission error
-        # it's a race condition between the timeout and send signal
-        except (PermissionError, SystemError):
-            pass
-        try:
-            # wait for the server to stop for maximum x seconds
-            self._local_server_process.wait(timeout=60)
-        except subprocess.TimeoutExpired:
-            proceed = QtWidgets.QMessageBox.question(self.parent(),
-                                                     "Local server",
-                                                     "The Local server cannot be stopped, would you like to kill it?",
-                                                     QtWidgets.QMessageBox.StandardButton.Yes,
-                                                     QtWidgets.QMessageBox.StandardButton.No)
-
-            if proceed == QtWidgets.QMessageBox.StandardButton.Yes:
-                self._local_server_process.kill()
-
-    @staticmethod
-    def instance():
-        """
-        Singleton to return only on instance of LocalServer.
-        :returns: instance of LocalServer
-        """
-
-        if not hasattr(LocalServer, '_instance') or LocalServer._instance is None:
-            LocalServer._instance = LocalServer()
-        return LocalServer._instance
-
-
-def main():
-    import pprint
-
-    pp = pprint.PrettyPrinter(indent=4)
-    print("Local server config")
-    local_server = LocalServer(False)
-    pp.pprint(local_server.localServerSettings())
-    local_server.localServerAutoStart()
-    local_server.stopLocalServer()
-
-
-if __name__ == '__main__':
-    main()

gns3/local_server_config.py

@@ -30,25 +30,22 @@ class LocalServerConfig:
     Local server configuration.
     """
 
-    def __init__(self, config_file=None):
+    def __init__(self):
 
         appname = "GNS3"
 
         self._config = configparser.RawConfigParser()
-
-        if config_file:
-            self._config_file = config_file
+        if sys.platform.startswith("win"):
+            filename = "gns3_server.ini"
         else:
-            if sys.platform.startswith("win"):
-                filename = "gns3_server.ini"
-            else:
-                filename = "gns3_server.conf"
+            filename = "gns3_server.conf"
 
-            from .local_config import LocalConfig
-            if sys.platform.startswith("win"):
-                self._config_file = os.path.join(LocalConfig.instance().configDirectory(), filename)
-            else:
-                self._config_file = os.path.join(LocalConfig.instance().configDirectory(), filename)
+        if sys.platform.startswith("win"):
+            appdata = os.path.expandvars("%APPDATA%")
+            self._config_file = os.path.join(appdata, appname, filename)
+        else:
+            home = os.path.expanduser("~")
+            self._config_file = os.path.join(home, ".config", appname, filename)
 
         try:
             # create the config file if it doesn't exist
@@ -57,14 +54,6 @@ class LocalServerConfig:
             log.error("Could not create the local server configuration {}: {}".format(self._config_file, e))
         self.readConfig()
 
-    def setConfigFile(self, path):
-        """
-        Change the location of the server config (use for test)
-        """
-        self._config = configparser.RawConfigParser()
-        self._config_file = path
-        self.readConfig()
-
     def readConfig(self):
         """
         Read the configuration file.
@@ -87,12 +76,13 @@ class LocalServerConfig:
         except (OSError, configparser.Error) as e:
             log.error("Could not write the local server configuration {}: {}".format(self._config_file, e))
 
-    def loadSettings(self, section, default_settings):
+    def loadSettings(self, section, default_settings, types):
         """
         Get all the settings from a given section.
 
         :param section: section name
         :param default_settings: setting names and default values (dict)
+        :param types: setting types (dict)
 
         :returns: settings (dict)
         """
@@ -102,16 +92,14 @@ class LocalServerConfig:
 
         settings = {}
         for name, default in default_settings.items():
-            if isinstance(default, bool):
-                settings[name] = self._config[section].getboolean(name, default)
-            elif isinstance(default, int):
+            if types[name] is int:
                 settings[name] = self._config[section].getint(name, default)
-            elif isinstance(default, float):
+            elif types[name] is bool:
+                settings[name] = self._config[section].getboolean(name, default)
+            elif types[name] is float:
                 settings[name] = self._config[section].getfloat(name, default)
             else:
                 settings[name] = self._config[section].get(name, default)
-                if settings[name] == "None":
-                    settings[name] = None
 
         # sync with the config file
         self.saveSettings(section, settings)
@@ -138,18 +126,6 @@ class LocalServerConfig:
         if changed:
             self.writeConfig()
 
-    def deleteSetting(self, section, name):
-        """
-        Delete a specific setting in a given section.
-
-        :param section: section name
-        :param name: setting name to delete
-        """
-
-        if section in self._config and name in self._config[section]:
-            del self._config[section][name]
-            self.writeConfig()
-
     @staticmethod
     def instance():
         """

gns3/logger.py

@@ -85,33 +85,14 @@ class ColouredStreamHandler(logging.StreamHandler):
 def init_logger(level, logfile, quiet=False):
     if sys.platform.startswith("win"):
         stream_handler = logging.StreamHandler(sys.stdout)
-        stream_handler.formatter = ColouredFormatter("{asctime} {levelname} {name}:{lineno} {message}", "%Y-%m-%d %H:%M:%S", "{")
+        stream_handler.formatter = ColouredFormatter("{asctime} {levelname} {filename}:{lineno} {message}", "%Y-%m-%d %H:%M:%S", "{")
     else:
         stream_handler = ColouredStreamHandler(sys.stdout)
-        stream_handler.formatter = ColouredFormatter("{asctime} {levelname} {name}:{lineno}#RESET# {message}", "%Y-%m-%d %H:%M:%S", "{")
+        stream_handler.formatter = ColouredFormatter("{asctime} {levelname} {filename}:{lineno}#RESET# {message}", "%Y-%m-%d %H:%M:%S", "{")
     logging.basicConfig(level=level, handlers=[stream_handler])
     log = logging.getLogger()
     log.addHandler(stream_handler)
 
-    log_factory = logging.getLogRecordFactory()
-
-    def factory(name, level, fn, lno, msg, args, exc_info, func=None, sinfo=None, **kwargs):
-        """
-        Reformat the log message to get something more clean
-        """
-        # When qt message box is display the correct line number is a part of
-        # the name
-        if ":" in name:
-            name, lno = name.split(":")
-            lno = int(lno)
-        name = name.replace("gns3.", "")
-        try:
-            return log_factory(name, level, fn, lno, msg, args, exc_info, func=func, sinfo=sinfo, **kwargs)
-        except Exception as e:  # To avoid recursion we just print the message if something is wrong when logging
-            print(msg)
-            return
-    logging.setLogRecordFactory(factory)
-
     try:
         try:
             os.makedirs(os.path.dirname(logfile))
@@ -121,7 +102,7 @@ def init_logger(level, logfile, quiet=False):
         handler.formatter = logging.Formatter("{asctime} {levelname} {filename}:{lineno} {message}", "%Y-%m-%d %H:%M:%S", "{")
         log.addHandler(handler)
     except OSError as e:
-        log.warning("could not log to {}: {}".format(logfile, e))
+        log.warn("could not log to {}: {}".format(logfile, e))
 
     log.info('Log level: {}'.format(logging.getLevelName(level)))
 

gns3/main.py

@@ -18,7 +18,6 @@
 
 import sys
 import os
-import faulthandler
 
 # Try to install updates & restart application if an update is installed
 try:
@@ -30,15 +29,26 @@ try:
 except Exception as e:
     print("Fail update installation: {}".format(str(e)))
 
+
+# WARNING
+# Due to buggy user machines we choose to put this as the first loading modules
+# otherwise the egg cache is initialized in his standard location and
+# if is not writetable the application crash. It's the user fault
+# because one day the user as used sudo to run an egg and break his
+# filesystem permissions, but it's a common mistake.
+from gns3.utils.get_resource import get_resource
+
+
 import datetime
 import traceback
 import time
 import locale
 import argparse
 import signal
+import psutil
 
 try:
-    from gns3.qt import QtCore, QtWidgets
+    from gns3.qt import QtCore, QtGui, QtWidgets
 except ImportError:
     raise SystemExit("Can't import Qt modules: Qt and/or PyQt is probably not installed correctly...")
 from gns3.main_window import MainWindow
@@ -48,13 +58,13 @@ from gns3.crash_report import CrashReport
 from gns3.local_config import LocalConfig
 from gns3.application import Application
 from gns3.utils import parse_version
-from gns3.dialogs.profile_select import ProfileSelectDialog
-from gns3.version import __version__
 
 
 import logging
 log = logging.getLogger(__name__)
 
+from gns3.version import __version__
+
 
 def locale_check():
     """
@@ -79,13 +89,13 @@ def locale_check():
         log.error("could not determine the current locale: {}".format(e))
     if not language and not encoding:
         try:
-            log.warning("could not find a default locale, switching to C.UTF-8...")
+            log.warn("could not find a default locale, switching to C.UTF-8...")
             locale.setlocale(locale.LC_ALL, ("C", "UTF-8"))
         except locale.Error as e:
             log.error("could not switch to the C.UTF-8 locale: {}".format(e))
             raise SystemExit
     elif encoding != "UTF-8":
-        log.warning("your locale {}.{} encoding is not UTF-8, switching to the UTF-8 version...".format(language, encoding))
+        log.warn("your locale {}.{} encoding is not UTF-8, switching to the UTF-8 version...".format(language, encoding))
         try:
             locale.setlocale(locale.LC_ALL, (language, "UTF-8"))
         except locale.Error as e:
@@ -100,50 +110,41 @@ def main():
     Entry point for GNS3 GUI.
     """
 
-    # Get Python tracebacks explicitly, on a fault like segfault
-    faulthandler.enable()
-
     # Sometimes (for example at first launch) the OSX app service launcher add
     # an extra argument starting with -psn_. We filter it
     if sys.platform.startswith("darwin"):
         sys.argv = [a for a in sys.argv if not a.startswith("-psn_")]
-        if parse_version(QtCore.QT_VERSION_STR) < parse_version("5.15.2"):
-            # Fixes issue on macOS Big Sur: https://github.com/GNS3/gns3-gui/issues/3037
-            os.environ["QT_MAC_WANTS_LAYER"] = "1"
 
     parser = argparse.ArgumentParser()
     parser.add_argument("project", help="load a GNS3 project (.gns3)", metavar="path", nargs="?")
     parser.add_argument("--version", help="show the version", action="version", version=__version__)
     parser.add_argument("--debug", help="print out debug messages", action="store_true", default=False)
-    parser.add_argument("-q", "--quiet", action="store_true", help="do not show logs on stdout")
     parser.add_argument("--config", help="Configuration file")
-    parser.add_argument("--profile", help="Settings profile (blank will use default settings files)")
     options = parser.parse_args()
     exception_file_path = "exceptions.log"
 
+    if options.config:
+        LocalConfig.instance(config_file=options.config)
+    else:
+        LocalConfig.instance()
+
     if options.project:
         options.project = os.path.abspath(options.project)
 
-    try:
-        import truststore
-        truststore.inject_into_ssl()
-        log.info("Using system certificate store for SSL connections")
-    except ImportError:
-        pass
-
     if hasattr(sys, "frozen"):
         # We add to the path where the OS search executable our binary location starting by GNS3
         # packaged binary
         frozen_dir = os.path.dirname(os.path.abspath(sys.executable))
         if sys.platform.startswith("darwin"):
-            frozen_dirs = [frozen_dir]
+            frozen_dirs = [
+                frozen_dir,
+                os.path.normpath(os.path.join(frozen_dir, '..', 'Resources'))
+            ]
         elif sys.platform.startswith("win"):
             frozen_dirs = [
                 frozen_dir,
                 os.path.normpath(os.path.join(frozen_dir, 'dynamips')),
-                os.path.normpath(os.path.join(frozen_dir, 'ubridge')),
-                os.path.normpath(os.path.join(frozen_dir, 'vpcs')),
-                os.path.normpath(os.path.join(frozen_dir, 'traceng'))
+                os.path.normpath(os.path.join(frozen_dir, 'vpcs'))
             ]
 
         os.environ["PATH"] = os.pathsep.join(frozen_dirs) + os.pathsep + os.environ.get("PATH", "")
@@ -151,7 +152,6 @@ def main():
         if options.project:
             os.chdir(frozen_dir)
 
-
     def exceptionHook(exception, value, tb):
 
         if exception == KeyboardInterrupt:
@@ -183,12 +183,19 @@ def main():
     # catch exceptions to write them in a file
     sys.excepthook = exceptionHook
 
-    # we only support Python 3 version >= 3.9
-    if sys.version_info < (3, 9):
-        raise SystemExit("Python 3.9 or higher is required")
+    current_year = datetime.date.today().year
+    print("GNS3 GUI version {}".format(__version__))
+    print("Copyright (c) 2007-{} GNS3 Technologies Inc.".format(current_year))
 
-    if parse_version(QtCore.QT_VERSION_STR) < parse_version("6.3.1"):
-        raise SystemExit("Requirement is PyQt6 version 6.3.1 or higher, got version {}".format(QtCore.QT_VERSION_STR))
+    # we only support Python 3 version >= 3.4
+    if sys.version_info < (3, 4):
+        raise SystemExit("Python 3.4 or higher is required")
+
+    if parse_version(QtCore.QT_VERSION_STR) < parse_version("5.0.0"):
+        raise SystemExit("Requirement is PyQt5 version 5.0.0 or higher, got version {}".format(QtCore.QT_VERSION_STR))
+
+    if parse_version(psutil.__version__) < parse_version("2.2.1"):
+        raise SystemExit("Requirement is psutil version 2.2.1 or higher, got version {}".format(psutil.__version__))
 
     # check for the correct locale
     # (UNIX/Linux only)
@@ -202,7 +209,7 @@ def main():
 
     # always use the INI format on Windows and OSX (because we don't like the registry and plist files)
     if sys.platform.startswith('win') or sys.platform.startswith('darwin'):
-        QtCore.QSettings.setDefaultFormat(QtCore.QSettings.Format.IniFormat)
+        QtCore.QSettings.setDefaultFormat(QtCore.QSettings.IniFormat)
 
     if sys.platform.startswith('win') and hasattr(sys, "frozen"):
         try:
@@ -215,88 +222,47 @@ def main():
         if not options.debug:
             try:
                 # hide the console
-                # win32console.AllocConsole()
                 console_window = win32console.GetConsoleWindow()
-                parent_window = win32gui.GetParent(console_window)
-                if not parent_window and console_window:
-                    win32gui.ShowWindow(console_window, win32con.SW_HIDE)
-                elif parent_window:
-                    win32gui.ShowWindow(parent_window, win32con.SW_HIDE)
-                else:
-                    log.warning("Could not get the console window")
+                win32gui.ShowWindow(console_window, win32con.SW_HIDE)
             except win32console.error as e:
-                log.warning("Could not allocate console: {}".format(e))
-
-    local_config = LocalConfig.instance()
+                print("warning: could not allocate console: {}".format(e))
 
     global app
     app = Application(sys.argv)
 
-    if local_config.multiProfiles() and not options.profile:
-        profile_select = ProfileSelectDialog()
-        profile_select.show()
-        if profile_select.exec():
-            options.profile = profile_select.profile()
-        else:
-            sys.exit(0)
-
-    # Init the config
-    if options.config:
-        local_config.setConfigFilePath(options.config)
-    elif options.profile:
-        local_config.setProfile(options.profile)
-
     # save client logging info to a file
-    logfile = os.path.join(LocalConfig.instance().configDirectory(), "gns3_gui.log")
+    logfile = os.path.join(LocalConfig.configDirectory(), "gns3_gui.log")
 
     # on debug enable logging to stdout
     if options.debug:
-        init_logger(logging.DEBUG, logfile)
-    elif options.quiet:
-        init_logger(logging.ERROR, logfile)
+        root_logger = init_logger(logging.DEBUG, logfile)
     else:
-        init_logger(logging.INFO, logfile)
-
-    current_year = datetime.date.today().year
-    log.info("GNS3 GUI version {}".format(__version__))
-    log.info("Copyright (c) 2007-{} GNS3 Technologies Inc.".format(current_year))
-    log.info("Application started with {}".format(" ".join(sys.argv)))
-    log.debug("PATH={}".format(os.environ["PATH"]))
+        root_logger = init_logger(logging.INFO, logfile)
 
     # update the exception file path to have it in the same directory as the settings file.
-    exception_file_path = os.path.join(LocalConfig.instance().configDirectory(), exception_file_path)
-
-    # We disallow to run GNS3 from outside the /Applications folder to avoid
-    # issue when people run GNS3 from the .dmg
-    if sys.platform.startswith("darwin") and hasattr(sys, "frozen"):
-        if not os.path.realpath(sys.executable).startswith("/Applications"):
-            error_message = "GNS3.app must be moved to the '/Applications' folder before it can be used"
-            QtWidgets.QMessageBox.critical(False, "Loading error", error_message)
-            QtCore.QTimer.singleShot(0, app.quit)
-            app.exec()
-            sys.exit(1)
+    exception_file_path = os.path.join(LocalConfig.configDirectory(), exception_file_path)
 
     global mainwindow
-    startup_file = app.open_file_at_startup
-    if not startup_file:
-        startup_file = options.project
-
-    mainwindow = MainWindow(open_file=startup_file)
+    mainwindow = MainWindow()
 
     # On OSX we can receive the file to open from a system event
     # loadPath is smart and will load only if a path is present
+    mainwindow.ready_signal.connect(lambda: mainwindow.loadPath(app.open_file_at_startup))
+    mainwindow.ready_signal.connect(lambda: mainwindow.loadPath(options.project))
     app.file_open_signal.connect(lambda path: mainwindow.loadPath(path))
 
     # Manage Ctrl + C or kill command
     def sigint_handler(*args):
         log.info("Signal received exiting the application")
+        mainwindow.setSoftExit(False)
         app.closeAllWindows()
     orig_sigint = signal.signal(signal.SIGINT, sigint_handler)
     orig_sigterm = signal.signal(signal.SIGTERM, sigint_handler)
 
     mainwindow.show()
 
-    exit_code = app.exec()
+    exit_code = app.exec_()
+
     signal.signal(signal.SIGINT, orig_sigint)
     signal.signal(signal.SIGTERM, orig_sigterm)
 
@@ -305,7 +271,7 @@ def main():
     # We force deleting the app object otherwise it's segfault on Fedora
     del app
     # We force a full garbage collect before exit
-    # for unknown reason otherwise Qt Segfault on OSX in some
+    # for unknow reason otherwise Qt Segfault on OSX in some
     # conditions
     import gc
     gc.collect()

gns3/modules/__init__.py

@@ -19,12 +19,9 @@ from gns3.modules.builtin import Builtin
 from gns3.modules.dynamips import Dynamips
 from gns3.modules.iou import IOU
 from gns3.modules.vpcs import VPCS
-from gns3.modules.traceng import TraceNG
 from gns3.modules.virtualbox import VirtualBox
 from gns3.modules.qemu import Qemu
 from gns3.modules.vmware import VMware
 from gns3.modules.docker import Docker
 
-#MODULES = [Builtin, VPCS, Dynamips, IOU, Qemu, VirtualBox, VMware, Docker, TraceNG]
-#FIXME: deactivate TraceNG module
-MODULES = [Builtin, VPCS, Dynamips, IOU, Qemu, VirtualBox, VMware, Docker]
+MODULES = [VPCS, Dynamips, IOU, Qemu, VirtualBox, VMware, Docker, Builtin]

gns3/modules/builtin/__init__.py

@@ -20,17 +20,10 @@ Built-in module implementation.
 """
 
 from gns3.qt import QtWidgets
-from gns3.local_config import LocalConfig
-from gns3.local_server_config import LocalServerConfig
-
 from ..module import Module
 from .cloud import Cloud
-from .nat import Nat
-from .ethernet_hub import EthernetHub
-from .ethernet_switch import EthernetSwitch
-from .frame_relay_switch import FrameRelaySwitch
-from .atm_switch import ATMSwitch
-from .settings import BUILTIN_SETTINGS
+from .host import Host
+
 
 import logging
 log = logging.getLogger(__name__)
@@ -44,74 +37,96 @@ class Builtin(Module):
 
     def __init__(self):
         super().__init__()
-        self._loadSettings()
 
-    def _saveSettings(self):
+        self._nodes = []
+
+    def configChangedSlot(self):
+        pass
+
+    def addNode(self, node):
         """
-        Saves the settings to the persistent settings file.
+        Adds a node to this module.
+
+        :param node: Node instance
         """
 
-        LocalConfig.instance().saveSectionSettings(self.__class__.__name__, self._settings)
+        self._nodes.append(node)
 
-        server_settings = {}
-        config = LocalServerConfig.instance()
-        if self._settings["default_nat_interface"]:
-            # save some settings to the local server config file
-            server_settings["default_nat_interface"] = self._settings["default_nat_interface"]
-            config.saveSettings(self.__class__.__name__, server_settings)
+    def removeNode(self, node):
+        """
+        Removes a node from this module.
+
+        :param node: Node instance
+        """
+
+        if node in self._nodes:
+            self._nodes.remove(node)
+
+    def reset(self):
+        """
+        Resets the module.
+        """
+
+        log.info("Built-in module reset")
+        self._nodes.clear()
+
+    def createNode(self, node_class, server, project):
+        """
+        Creates a new node.
+
+        :param node_class: Node object
+        :param server: HTTPClient instance
+        :param project: Project instance
+        """
+
+        log.info("creating node {}".format(node_class))
+
+        # create an instance of the node class
+        return node_class(self, server, project)
+
+    def setupNode(self, node, node_name):
+        """
+        Setups a node.
+
+        :param node: Node instance
+        :param node_name: Node name
+        """
+
+        log.info("configuring node {}".format(node))
+        node.setup()
+
+    @staticmethod
+    def findAlternativeInterface(node, missing_interface):
+
+        from gns3.main_window import MainWindow
+        mainwindow = MainWindow.instance()
+
+        available_interfaces = []
+        for interface in node.settings()["interfaces"]:
+            available_interfaces.append(interface["name"])
+
+        if available_interfaces:
+            selection, ok = QtWidgets.QInputDialog.getItem(mainwindow,
+                                                           "Cloud interfaces", "Interface {} could not be found\nPlease select an alternative from your existing interfaces:".format(missing_interface),
+                                                           available_interfaces, 0, False)
+            if ok:
+                return selection
+            QtWidgets.QMessageBox.warning(mainwindow, "Cloud interface", "No alternative interface chosen to replace {} on this host, this may lead to issues".format(missing_interface))
+            return None
         else:
-            config.deleteSetting(self.__class__.__name__, "default_nat_interface")
-
-    def _loadSettings(self):
-        """
-        Loads the settings from the persistent settings file.
-        """
-
-        local_config = LocalConfig.instance()
-        self._settings = local_config.loadSectionSettings(self.__class__.__name__, BUILTIN_SETTINGS)
+            QtWidgets.QMessageBox.critical(mainwindow, "Cloud interface", "Could not find interface {} on this host".format(missing_interface))
+            return missing_interface
 
     @staticmethod
-    def configurationPage(node_type):
+    def getNodeClass(name):
         """
-        Returns the configuration page for this module.
+        Returns the object with the corresponding name.
 
-        :returns: QWidget object
+        :param name: object name
         """
 
-        from .pages.ethernet_hub_configuration_page import EthernetHubConfigurationPage
-        from .pages.ethernet_switch_configuration_page import EthernetSwitchConfigurationPage
-        from .pages.cloud_configuration_page import CloudConfigurationPage
-        if node_type == "ethernet_hub":
-            return EthernetHubConfigurationPage
-        elif node_type == "ethernet_switch":
-            return EthernetSwitchConfigurationPage
-        elif node_type == "cloud":
-            return CloudConfigurationPage
-        return None
-
-    @staticmethod
-    def getNodeClass(node_type, platform=None):
-        """
-        Returns the class corresponding to node type.
-
-        :param node_type: node type (string)
-        :param platform: not used
-
-        :returns: class or None
-        """
-
-        if node_type == "cloud":
-            return Cloud
-        elif node_type == "nat":
-            return Nat
-        elif node_type == "ethernet_hub":
-            return EthernetHub
-        elif node_type == "ethernet_switch":
-            return EthernetSwitch
-        elif node_type == "frame_relay_switch":
-            return FrameRelaySwitch
-        elif node_type == "atm_switch":
-            return ATMSwitch
+        if name in globals():
+            return globals()[name]
         return None
 
     @staticmethod
@@ -122,7 +137,24 @@ class Builtin(Module):
         :returns: list of classes
         """
 
-        return [Nat, Cloud, EthernetHub, EthernetSwitch, FrameRelaySwitch, ATMSwitch]
+        return [Cloud, Host]
+
+    def nodes(self):
+        """
+        Returns all the node data necessary to represent a node
+        in the nodes view and create a node on the scene.
+        """
+
+        nodes = []
+        for node_class in Builtin.classes():
+            nodes.append(
+                {"class": node_class.__name__,
+                 "name": node_class.symbolName(),
+                 "categories": node_class.categories(),
+                 "symbol": node_class.defaultSymbol(),
+                 "builtin": True}
+            )
+        return nodes
 
     @staticmethod
     def preferencePages():
@@ -130,12 +162,7 @@ class Builtin(Module):
         :returns: QWidget object list
         """
 
-        from .pages.builtin_preferences_page import BuiltinPreferencesPage
-        from .pages.cloud_preferences_page import CloudPreferencesPage
-        from .pages.ethernet_hub_preferences_page import EthernetHubPreferencesPage
-        from .pages.ethernet_switch_preferences_page import EthernetSwitchPreferencesPage
-
-        return [BuiltinPreferencesPage, EthernetHubPreferencesPage, EthernetSwitchPreferencesPage, CloudPreferencesPage]
+        return []
 
     @staticmethod
     def instance():
@@ -148,10 +175,3 @@ class Builtin(Module):
         if not hasattr(Builtin, "_instance"):
             Builtin._instance = Builtin()
         return Builtin._instance
-
-    def __str__(self):
-        """
-        Returns the module name.
-        """
-
-        return "builtin"

gns3/modules/builtin/atm_switch.py

@@ -1,145 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2014 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
-
-from gns3.node import Node
-
-import logging
-log = logging.getLogger(__name__)
-
-
-class ATMSwitch(Node):
-
-    """
-    ATM switch.
-
-    :param module: parent module for this node
-    :param server: GNS3 server instance
-    :param project: Project instance
-    """
-
-    URL_PREFIX = "atm_switch"
-
-    def __init__(self, module, server, project):
-
-        super().__init__(module, server, project)
-        # this is an always-on node
-        self.setStatus(Node.started)
-        self._always_on = True
-        self.settings().update({"mappings": {}})
-
-    def info(self):
-        """
-        Returns information about this ATM switch.
-
-        :returns: formatted string
-        """
-
-        info = """ATM switch {name} is always-on
-  Running on server {host} with port {port}
-  Local ID is {id} and server ID is {node_id}
-  Hardware is Dynamips emulated simple ATM switch
-""".format(name=self.name(),
-           id=self.id(),
-           node_id=self._node_id,
-           host=self._compute.name(),
-           port=self._compute.port())
-
-        port_info = ""
-        mapping = re.compile(r"""^([0-9]*):([0-9]*):([0-9]*)$""")
-        for port in self._ports:
-            if port.isFree():
-                port_info += "   Port {} is empty\n".format(port.name())
-            else:
-                port_info += "   Port {name} {description}\n".format(name=port.name(),
-                                                                     description=port.description())
-
-            for source, destination in self._settings["mappings"].items():
-                match_source_mapping = mapping.search(source)
-                match_destination_mapping = mapping.search(destination)
-                if match_source_mapping and match_destination_mapping:
-                    source_port, source_vpi, source_vci = match_source_mapping.group(1, 2, 3)
-                    destination_port, destination_vpi, destination_vci = match_destination_mapping.group(1, 2, 3)
-                else:
-                    source_port, source_vpi = source.split(":")
-                    destination_port, destination_vpi = destination.split(":")
-                    source_vci = destination_vci = 0
-
-                if port.name() == source_port or port.name() == destination_port:
-                    if port.name() == source_port:
-                        vpi1 = source_vpi
-                        vci1 = source_vci
-                        port = destination_port
-                        vci2 = destination_vci
-                        vpi2 = destination_vpi
-                    else:
-                        vpi1 = destination_vpi
-                        vci1 = destination_vci
-                        port = source_port
-                        vci2 = source_vci
-                        vpi2 = source_vpi
-
-                    if vci1 and vci2:
-                        port_info += "      incoming VPI {vpi1} and VCI {vci1} is switched to port {port} outgoing VPI {vpi2} and VCI {vci2}\n".format(vpi1=vpi1,
-                                                                                                                                                       vci1=vci1,
-                                                                                                                                                       port=port,
-                                                                                                                                                       vpi2=vpi2,
-                                                                                                                                                       vci2=vci2)
-                    else:
-                        port_info += "      incoming VPI {vpi1} is switched to port {port} outgoing VPI {vpi2}\n".format(vpi1=vpi1,
-                                                                                                                         port=port,
-                                                                                                                         vpi2=vpi2)
-
-                    break
-
-        return info + port_info
-
-    def configPage(self):
-        """
-        Returns the configuration page widget to be used by the node properties dialog.
-
-        :returns: QWidget object
-        """
-
-        from .pages.atm_switch_configuration_page import ATMSwitchConfigurationPage
-        return ATMSwitchConfigurationPage
-
-    @staticmethod
-    def defaultSymbol():
-        """
-        Returns the default symbol path for this node.
-
-        :returns: symbol path (or resource).
-        """
-
-        return ":/symbols/atm_switch.svg"
-
-    @staticmethod
-    def categories():
-        """
-        Returns the node categories the node is part of (used by the device panel).
-
-        :returns: list of node categories
-        """
-
-        return [Node.switches]
-
-    def __str__(self):
-
-        return "ATM switch"

gns3/modules/builtin/cloud.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2016 GNS3 Technologies Inc.
+# Copyright (C) 2014 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
@@ -15,8 +15,21 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+"""
+NIO implementation on the client side (in the form of a pseudo node represented as a cloud).
+"""
+
+import re
 from gns3.node import Node
-from .settings import CLOUD_SETTINGS
+from gns3.ports.port import Port
+from gns3.nios.nio_generic_ethernet import NIOGenericEthernet
+from gns3.nios.nio_linux_ethernet import NIOLinuxEthernet
+from gns3.nios.nio_nat import NIONAT
+from gns3.nios.nio_udp import NIOUDP
+from gns3.nios.nio_tap import NIOTAP
+from gns3.nios.nio_unix import NIOUNIX
+from gns3.nios.nio_vde import NIOVDE
+from gns3.nios.nio_null import NIONull
 
 import logging
 log = logging.getLogger(__name__)
@@ -25,111 +38,286 @@ log = logging.getLogger(__name__)
 class Cloud(Node):
 
     """
-    Cloud node
+    Dynamips cloud.
 
     :param module: parent module for this node
     :param server: GNS3 server instance
     :param project: Project instance
     """
 
-    URL_PREFIX = "cloud"
+    _name_instance_count = 1
 
     def __init__(self, module, server, project):
 
         super().__init__(module, server, project)
-        # this is an always-on node
-        self.setStatus(Node.started)
-        self._always_on = True
-        self._interfaces = {}
-        self._cloud_settings = {"ports_mapping": [],
-                                "remote_console_host": CLOUD_SETTINGS["remote_console_host"],
-                                "remote_console_port": CLOUD_SETTINGS["remote_console_port"],
-                                "remote_console_type": CLOUD_SETTINGS["remote_console_type"],
-                                "remote_console_http_path": CLOUD_SETTINGS["remote_console_http_path"]
-                                }
-        self.settings().update(self._cloud_settings)
 
-    def interfaces(self):
+        log.info("cloud is being created")
+        # create an unique id and name
+        self._name_id = Cloud._name_instance_count
+        Cloud._name_instance_count += 1
 
-        return self._interfaces
+        name = "Cloud {}".format(self._name_id)
+        self.setStatus(Node.started)  # this is an always-on node
+        self._initial_settings = None
+        self._settings = {"name": name,
+                          "interfaces": {},
+                          "nios": []}
 
-    def _createCallback(self, result):
+    def delete(self):
         """
-        Callback for create.
+        Deletes this cloud.
+        """
+
+        # first delete all the links attached to this node
+        self.delete_links_signal.emit()
+        self.deleted_signal.emit()
+
+    def setup(self, name=None, additional_settings={}):
+        """
+        Setups this cloud.
+
+        :param name: optional name for this cloud
+        """
+
+        if name:
+            self._settings["name"] = name
+
+        if additional_settings and "nios" in additional_settings:
+            self._settings["nios"] = additional_settings["nios"]
+
+        self._server.get("/interfaces", self._setupCallback)
+
+    def _setupCallback(self, result, error=False, **kwargs):
+        """
+        Callback for setup.
 
         :param result: server response
+        :param error: indicates an error (boolean)
         """
 
-        if "interfaces" in result:
-            self._interfaces = result["interfaces"].copy()
+        if error:
+            log.error("error while setting up {}: {}".format(self.name(), result["message"]))
+            # a warning message instead of a error is more appropriate here
+            self.warning_signal.emit(self.id(), result["message"])
+        else:
+            self._settings["interfaces"] = result.copy()
 
-    def _updateCallback(self, result):
+        if self._settings["nios"]:
+            self._addPorts(self._settings["nios"])
+
+        if self._loading:
+            self.loaded_signal.emit()
+        else:
+            self.setInitialized(True)
+            log.info("cloud {} has been created".format(self.name()))
+            self.created_signal.emit(self.id())
+            self._module.addNode(self)
+
+    def _createNIOUDP(self, nio):
         """
-        Callback for update.
+        Creates a NIO UDP.
 
-        :param result: server response
+        :param nio: nio string
         """
 
-        if "interfaces" in result:
-            self._interfaces = result["interfaces"].copy()
+        match = re.search(r"""^nio_udp:(\d+):(.+):(\d+)$""", nio)
+        if match:
+            lport = int(match.group(1))
+            rhost = match.group(2)
+            rport = int(match.group(3))
+            return NIOUDP(lport, rhost, rport)
+        return None
 
-    def consoleType(self):
+    def _createNIOGenericEthernet(self, nio):
         """
-        Get the console type.
+        Creates a NIO Generic Ethernet.
+
+        :param nio: nio string
         """
 
-        return self.settings()["remote_console_type"]
+        match = re.search(r"""^nio_gen_eth:(.+)$""", nio)
+        if match:
+            ethernet_device = match.group(1)
+            return NIOGenericEthernet(ethernet_device)
+        return None
 
-    def consoleHost(self):
+    def _createNIOLinuxEthernet(self, nio):
         """
-        Returns the host to connect to the console.
+        Creates a NIO Linux Ethernet.
 
-        :returns: host (string)
+        :param nio: nio string
         """
 
-        return self.settings()["remote_console_host"]
+        match = re.search(r"""^nio_gen_linux:(.+)$""", nio)
+        if match:
+            linux_device = match.group(1)
+            return NIOLinuxEthernet(linux_device)
+        return None
 
-    def console(self):
+    def _createNIONAT(self, nio):
         """
-        Returns the console port number of this node
+        Creates a NIO NAT.
 
-        :returns: port number
+        :param nio: nio string
         """
 
-        return self.settings()["remote_console_port"]
+        match = re.search(r"""^nio_nat:(.+)$""", nio)
+        if match:
+            identifier = match.group(1)
+            return NIONAT(identifier)
+        return None
 
-    def consoleHttpPath(self):
+    def _createNIOTAP(self, nio):
         """
-        Returns the path of the web ui
+        Creates a NIO TAP.
 
-        :returns: string
+        :param nio: nio string
         """
-        return self._settings["remote_console_http_path"]
+
+        match = re.search(r"""^nio_tap:(.+)$""", nio)
+        if match:
+            tap_device = match.group(1)
+            return NIOTAP(tap_device)
+        return None
+
+    def _createNIOUNIX(self, nio):
+        """
+        Creates a NIO UNIX.
+
+        :param nio: nio string
+        """
+
+        match = re.search(r"""^nio_unix:(.+):(.+)$""", nio)
+        if match:
+            local_file = match.group(1)
+            remote_file = match.group(2)
+            return NIOUNIX(local_file, remote_file)
+        return None
+
+    def _createNIOVDE(self, nio):
+        """
+        Creates a NIO VDE.
+
+        :param nio: nio string
+        """
+
+        match = re.search(r"""^nio_vde:(.+):(.+)$""", nio)
+        if match:
+            control_file = match.group(1)
+            local_file = match.group(2)
+            return NIOVDE(control_file, local_file)
+        return None
+
+    def _createNIONull(self, nio):
+        """
+        Creates a NIO Null.
+
+        :param nio: nio string
+        """
+
+        match = re.search(r"""^nio_null:(.+)$""", nio)
+        if match:
+            identifier = match.group(1)
+            return NIONull(identifier)
+        return None
+
+    def _allocateNIO(self, nio):
+        """
+        Allocate a new NIO object.
+
+        :param nio: NIO description
+
+        :returns: NIO instance
+        """
+
+        nio_object = None
+        if nio.lower().startswith("nio_udp"):
+            nio_object = self._createNIOUDP(nio)
+        if nio.lower().startswith("nio_gen_eth"):
+            nio_object = self._createNIOGenericEthernet(nio)
+        if nio.lower().startswith("nio_gen_linux"):
+            nio_object = self._createNIOLinuxEthernet(nio)
+        if nio.lower().startswith("nio_nat"):
+            nio_object = self._createNIONAT(nio)
+        if nio.lower().startswith("nio_tap"):
+            nio_object = self._createNIOTAP(nio)
+        if nio.lower().startswith("nio_unix"):
+            nio_object = self._createNIOUNIX(nio)
+        if nio.lower().startswith("nio_vde"):
+            nio_object = self._createNIOVDE(nio)
+        if nio.lower().startswith("nio_null"):
+            nio_object = self._createNIONull(nio)
+        if nio_object is None:
+            log.error("Could not create NIO object from {}".format(nio))
+        return nio_object
+
+    def _addPorts(self, nios, ignore_existing_nio=False):
+        """
+        Adds adapters.
+
+        :param adapters: number of adapters
+        """
+
+        # add ports
+        for nio in nios:
+            if ignore_existing_nio and nio in self._settings["nios"]:
+                # port already created for this NIO
+                continue
+            nio_object = self._allocateNIO(nio)
+            if nio_object is None:
+                continue
+            port = Port(nio, nio_object, stub=True)
+            port.setStatus(Port.started)
+            self._ports.append(port)
+            log.debug("port {} has been added".format(nio))
+
+    def update(self, new_settings):
+        """
+        Updates the settings for this cloud.
+
+        :param new_settings: settings dictionary
+        """
+
+        updated = False
+        if "nios" in new_settings:
+            nios = new_settings["nios"]
+            self._addPorts(nios, ignore_existing_nio=True)
+            updated = True
+
+            # delete ports
+            for nio in self._settings["nios"]:
+                if nio not in nios:
+                    for port in self._ports.copy():
+                        if port.name() == nio:
+                            self._ports.remove(port)
+                            updated = True
+                            log.debug("port {} has been deleted".format(nio))
+                            break
+
+            self._settings["nios"] = new_settings["nios"].copy()
+
+        if "name" in new_settings and new_settings["name"] != self.name():
+            self._settings["name"] = new_settings["name"]
+            updated = True
+
+        if updated:
+            log.info("cloud {} has been updated".format(self.name()))
+            self.updated_signal.emit()
+
+    def deleteNIO(self, port):
+
+        pass
 
     def info(self):
         """
         Returns information about this cloud.
 
-        :returns: formatted string
+        :returns: formated string
         """
 
-        info = """Cloud {name} is always-on
-  Running on server {host} with port {port}
-""".format(name=self.name(),
-           host=self.compute().name(),
-           port=self.compute().port())
-
-        if self.consoleType() != "none":
-            info += """   Remote console is {console_host} on port {console} and type is {console_type}
-""".format(console_host=self.consoleHost(),
-           console=self.console(),
-           console_type=self.consoleType())
-            if self.consoleType() in ("http", "https"):
-                info += """   Remote console HTTP path is '{console_http_path}'
-""".format(console_http_path=self.consoleHttpPath())
-        else:
-            info += """   No remote console configured
-"""
+        info = """Cloud device {name} is always-on
+This is a pseudo-device for external connections
+""".format(name=self.name())
 
         port_info = ""
         for port in self._ports:
@@ -139,8 +327,124 @@ class Cloud(Node):
                 port_info += "   Port {name} {description}\n".format(name=port.name(),
                                                                      description=port.description())
 
+            # add the Windows interface name
+            match = re.search(r"""^nio_gen_eth:(\\device\\npf_.+)$""", port.name())
+            if match:
+                for interface in self._settings["interfaces"]:
+                    if interface["name"].lower() == match.group(1):
+                        port_info += "      Windows name: {}\n".format(interface["description"])
+                        break
+
         return info + port_info
 
+    def dump(self):
+        """
+        Returns a representation of this cloud
+        (to be saved in a topology file).
+
+        :returns: representation of the node (dictionary)
+        """
+
+        cloud = {"id": self.id(),
+                 "type": self.__class__.__name__,
+                 "description": str(self),
+                 "properties": {"name": self.name(),
+                                "nios": self._settings["nios"]},
+                 "server_id": self._server.id()}
+
+        # add the ports
+        if self._ports:
+            ports = cloud["ports"] = []
+            for port in self._ports:
+                ports.append(port.dump())
+
+        return cloud
+
+    def load(self, node_info):
+        """
+        Loads a cloud representation
+        (from a topology file).
+
+        :param node_info: representation of the node (dictionary)
+        """
+
+        settings = node_info["properties"]
+        name = settings.pop("name")
+        log.info("cloud {} is loading".format(name))
+        self.setName(name)
+        self._loading = True
+        self._node_info = node_info
+        self.loaded_signal.connect(self._updatePortSettings)
+        self.setup(name, additional_settings=settings)
+
+    def _updatePortSettings(self):
+        """
+        Updates port settings when loading a topology.
+        """
+
+        self.loaded_signal.disconnect(self._updatePortSettings)
+
+        # update the port with the correct IDs
+        if "ports" in self._node_info:
+            ports = self._node_info["ports"]
+            for topology_port in ports:
+                for port in self._ports:
+                    if topology_port["name"] == port.name():
+                        port.setId(topology_port["id"])
+                        if topology_port["name"].startswith("nio_gen_eth") or topology_port["name"].startswith("nio_linux_eth"):
+                            # lookup if the interface exists
+                            available_interface = False
+                            topology_port_name = topology_port["name"].split(':', 1)[1]
+                            for interface in self._settings["interfaces"]:
+                                if interface["name"] == topology_port_name:
+                                    available_interface = True
+                                    break
+                            if not available_interface:
+                                alternative_interface = self._module.findAlternativeInterface(self, topology_port_name)
+                                if alternative_interface:
+                                    if topology_port["name"] in self._settings["nios"]:
+                                        self._settings["nios"].remove(topology_port["name"])
+                                    topology_port["name"] = topology_port["name"].replace(topology_port_name, alternative_interface)
+                                    nio = self._allocateNIO(topology_port["name"])
+                                    port.setDefaultNio(nio)
+                                    port.setName(topology_port["name"])
+                                    self._settings["nios"].append(topology_port["name"])
+
+        # now we can set the node as initialized and trigger the created signal
+        self.setInitialized(True)
+        log.info("cloud {} has been loaded".format(self.name()))
+        self.created_signal.emit(self.id())
+        self._module.addNode(self)
+        self._loading = False
+        self._node_info = None
+
+    def name(self):
+        """
+        Returns the name of this cloud.
+
+        :returns: name (string)
+        """
+
+        return self._settings["name"]
+
+    def settings(self):
+        """
+        Returns all this cloud settings.
+
+        :returns: settings dictionary
+        """
+
+        return self._settings
+
+    def ports(self):
+        """
+        Returns all the ports for this cloud.
+
+        :returns: list of Port instances
+        """
+
+        return self._ports
+
     def configPage(self):
         """
         Returns the configuration page widget to be used by the node properties dialog.
@@ -161,12 +465,17 @@ class Cloud(Node):
 
         return ":/symbols/cloud.svg"
 
+    @staticmethod
+    def symbolName():
+
+        return "Cloud"
+
     @staticmethod
     def categories():
         """
         Returns the node categories the node is part of (used by the device panel).
 
-        :returns: list of node categories
+        :returns: list of node category (integer)
         """
 
         return [Node.end_devices]

gns3/modules/builtin/dialogs/cloud_wizard.py

@@ -1,54 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2016 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/>.
-
-"""
-Wizard for cloud nodes.
-"""
-
-from gns3.qt import QtGui, QtWidgets
-from gns3.dialogs.vm_wizard import VMWizard
-
-from ..ui.cloud_wizard_ui import Ui_CloudNodeWizard
-
-
-class CloudWizard(VMWizard, Ui_CloudNodeWizard):
-
-    """
-    Wizard to create a cloud node.
-
-    :param parent: parent widget
-    """
-
-    def __init__(self, cloud_nodes, parent):
-
-        super().__init__(cloud_nodes, parent)
-
-        self.setPixmap(QtWidgets.QWizard.WizardPixmap.LogoPixmap, QtGui.QPixmap(":/symbols/cloud.svg"))
-        self.uiNameWizardPage.registerField("name*", self.uiNameLineEdit)
-
-    def getSettings(self):
-        """
-        Returns the settings set in this Wizard.
-
-        :return: settings dict
-        """
-
-        settings = {"name": self.uiNameLineEdit.text(),
-                    "symbol": ":/symbols/cloud.svg",
-                    "compute_id": self._compute_id}
-
-        return settings