Release v3.0.5

# Conflicts:
#	CHANGELOG
#	gns3/crash_report.py
#	gns3/version.py

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

@@ -0,0 +1,34 @@
+---
+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

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

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

@@ -0,0 +1,25 @@
+---
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,93 @@
+# 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

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

.gitignore

@@ -63,3 +63,4 @@ __pycache__
 
 # Virtualenv
 env
+venv

.pyup.yml

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

.travis.yml

@@ -1,21 +0,0 @@
-sudo: required
-services:
-- docker
-notifications:
-  email: false
-script:
-- docker build -t gns3-gui-test .
-- docker run gns3-gui-test
-before_deploy:
-- sudo pip install twine
-- sudo pip install urllib3[secure]
-deploy:
-  provider: pypi
-  edge:
-    branch: v1.8.45
-  user: noplay
-  password:
-    secure: FofcqlJjgqf2jaDaXpLHeigVoexbrOz3WwnDuiJpwJxeFUlPY8s2cQs/Bm+dzxzZaOaGiVE0A83v/Xa10yD5tflThHt4sqYJK3iQCinA7wgeAlDimB4xrWUNplfNJZ/Eod5Ssa++E02W+3i29PxpXY//mjCY7qDxaoxul1gnFJY=
-  on:
-    tags: true
-    repo: GNS3/gns3-gui

.whitesource

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

AUTHORS

@@ -1,2 +0,0 @@
-Jeremy Grossmann
-Julien Duponchelle

CHANGELOG

@@ -1,5 +1,758 @@
 # Change Log
 
+## 3.0.5 14/05/2025
+
+* Merge remote-tracking branch 'origin/2.2' into 3.0
+* Merge remote-tracking branch 'origin/2.2' into 3.0
+* Development on 2.2.55.dev1
+* Release v2.2.54
+* Development on 2.2.54.dev1
+* Replace "Docker hub" by "Docker repository" because it is possible to use different repositories
+* Upgrade dependencies
+* Fix bring console in front when clicking on "Open all consoles". Fixes #3706
+* Upgrade dependencies
+* Allow password greater than 8 characters. Ref #3714
+* Development on 3.0.5.dev1
+* Add -F arg to wmctrl. Ref #3706
+
+## 2.2.54 21/04/2025
+
+* Replace "Docker hub" by "Docker repository" because it is possible to use different repositories
+* Upgrade dependencies
+* Fix bring console in front when clicking on "Open all consoles". Fixes #3706
+* Add -F arg to wmctrl. Ref #3706
+
+## 3.0.4 25/02/2025
+
+* Upgrade dependencies
+* Fix auto idle-pc for IOS templates
+* Add user info and password change for logged-in user. Fixes #3698
+
+## 3.0.3 22/01/2025
+
+* Set minimum duration for progress dialog when uploading. Ref https://github.com/GNS3/gns3-gui/issues/3682
+* Add logs when uploading images to the controller
+* Option to disable SSL certificate verification for future connections. Fixes https://github.com/GNS3/gns3-gui/issues/3694
+* Fix packet capture when connected to a controller with SSL. Fixes https://github.com/GNS3/gns3-gui/issues/3696
+* Update status after importing an image when installing a new appliance. Fixes #3691
+* Update file browser filters to find IOU images without extension. Fixes #3692
+* Upgrade dependencies
+
+## 2.2.53 21/01/2025
+
+* Update file browser filters for all files and IOU images
+* Upgrade dependencies
+* Fix Linux Mint default terminal configuration
+
+## 3.0.2 03/01/2025
+
+* Add button to create templates based on images that are not used by any yet.
+* Add "prune" images button in image management dialog.
+* Use the controller image endpoint to install appliances
+* Drop Python 3.8
+* Add image info tooltip in image management dialog.
+* Upgrade dependencies
+* Apply grid color via css property
+
+## 3.0.1 27/12/2024
+
+* Fix issue when image is already on the local server. Fixes https://github.com/GNS3/gns3-gui/issues/3678
+* Fix image uploading when image name differs with the image name recorded in the appliance. Fixes https://github.com/GNS3/gns3-gui/issues/3682
+* Fix Linux Mint default terminal configuration
+
+## 3.0.0 20/12/2024
+
+* Change title of QMessageBox
+
+## 2.2.52 02/12/2024
+
+* Add iol extension filter. Ref #3664
+* Remove maximum 64GB RAM limitation for QEMU VMs. Fixes #3658
+* Bring to front support for consoles on Linux.
+* Relax setuptools requirement to allow for easier Debian packaging on Ubuntu Focal & Jammy
+
+## 3.0.0rc2 20/11/2024
+
+* Remove maximum 64GB RAM limitation for QEMU VMs. Fixes #3658
+* Fix GUI connection to server.
+* Bring to front support for consoles on Linux.
+* Relax setuptools requirement to allow for easier Debian packaging on Ubuntu Focal & Jammy
+* Do not include tokens in notification logs
+* Python 3.13 support
+
+
+## 2.2.51 07/11/2024
+
+* Python 3.13 support
+* Upgrade dependencies
+* Add keyboard shortcut for Add Link
+
+## 2.2.50 21/10/2024
+
+* Fix issue when pid file contains invalid data
+* Add comment to indicate sentry-sdk is optional. Ref https://github.com/GNS3/gns3-server/issues/2423
+* Improve information provided when uploading invalid appliance image. Fixes #3637
+* Use "experimental features" option to force listening for HTTP notification streams. Ref #3579
+* Fix to allow packet capture on more than 6 links. Fixes #3594
+* Support for configuring MAC address in Docker containers
+* Add KRDC to pre-configured VNC console commands
+
+## 3.0.0rc1 11/08/2024
+
+* Add keep the original compute IDs option when exporting a project
+
+## 2.2.49 06/08/2024
+
+* Upgrade jsonschema and sentry-sdk packages
+* Upgrade to PyQt5 v5.15.11
+* Add shortcuts info dialog
+* Added Key Shortcuts
+
+## 2.2.48.1 12/07/2024
+
+* No changes
+
+## 2.2.48 08/07/2024
+
+* Use "experimental features" to allow bypassing hostname validation. Ref #3524
+* Update appliance_v8.json. Ref https://github.com/GNS3/gns3-registry/pull/897
+* Option to keep the compute IDs unchanged when exporting a project
+* Upgrade sentry-sdk and psutil packages
+* Switch to PyQt5 5.15.10 for macOS build
+
+## 3.0.0b3 19/05/2024
+
+* Fix updating IOS router
+* Ensure Python >= 3.8 is used in pyproject.toml
+
+## 2.2.47 15/05/2024
+
+* Remove maximum size for capture dialog. Ref #3576
+* Change sentry-sdk version
+* Upgrade aiohttp, sentry-sdk and truststore
+* Upgrade jsonschema and aiohttp
+* Drop Python 3.7
+* Remove dev requirements for Python 3.6
+* Add NAT symbols
+* Only show log message if event has "message"
+
+## 3.0.0b2 07/04/2024
+
+* Enable local controller support on Linux
+* Support for custom Qemu path in templates and nodes
+* Round CPUs value in Docker templates and VMs. Ref https://github.com/GNS3/gns3-gui/issues/3572
+
+## 2.2.46 26/02/2024
+
+* Add GNS3 console command "env" to show what environment variables are used. Ref https://github.com/GNS3/gns3-server/issues/2306
+* Add CTRL+C shortcut to copy status bar message. Ref #3561
+* Key modifier (ALT) to ignore snap to grid. Fixes #3538
+* Increase timeout to 5s for status bar messages. The coordinates message has no timeout and can be reset when clicking on the scene. Ref #3561
+* Add reset GUI state feature. Ref #3549
+* Fix for hiding Windows terminal. Ref #3290
+* Drop support for Python 3.6
+* Upgrade sentry-sdk, psutil and distro dependencies
+
+## 2.2.45 12/01/2024
+
+* Add missing console_type values in appliance_v8.json. Ref https://github.com/GNS3/gns3-registry/issues/849
+* Handle moved project notifications on controller stream
+* Add debug for PATH env variable
+* Add custom executable paths on Windows
+* Add --suppressApplicationTitle for Windows terminal. Fixes https://github.com/GNS3/gns3-gui/issues/3544
+* Upgrade sentry-sdk and aiohttp
+
+## 3.0.0b1 27/11/2023
+
+* Upgrade sentry-sdk to v1.37.1
+* Deactivate showing a percentage in progress bar. Ref #3543
+
+## 3.0.0a6 15/11/2023
+
+* Possible fix for stuck image upload. Ref https://github.com/GNS3/gns3-server/issues/2310
+* Fix timeout issue when creating Qemu disk image. Fixes https://github.com/GNS3/gns3-server/issues/2313
+* Add ISO file to images filter in Image Manager. Ref https://github.com/GNS3/gns3-server/issues/2310
+* Update custom command help and protect against double quote in project name
+* Refactor command variables support
+* Pass os.environ in Popen()
+* Add the ability to edit width and height in the style edit dialog.
+
+## 2.2.44.1 07/11/2023
+
+* No changes
+
+## 2.2.44 06/11/2023
+
+* Fix timeout issue when creating Qemu disk image. Fixes https://github.com/GNS3/gns3-server/issues/2313
+* Refactor command variables support
+* Add vendor_logo_url in appliance schemas. Ref https://github.com/GNS3/gns3-registry/pull/825
+* Add Qemu IGB network device
+* Add the ability to edit width and height in the style edit dialog.
+
+## 3.0.0a5 27/10/2023
+
+* Upgrade to actions/checkout@v3 and actions/setup-python@v3
+* Fix cannot change default VLAN for an access port for builtin Ethernet switch. Fixes #3528
+* Add Qemu IGB network device
+
+## 3.0.0a4 18/10/2023
+
+* New packaging relying only pyproject.toml
+* Apply Snap-to-grid of drawing items not on their center position. Fixes #3465
+* Allow computes to be dynamically or manually allocated
+* Add UEFI boot mode option for Qemu VMs
+* Adjust some values in pyproject.toml
+* Migrate to pyproject.toml
+* Mark VMware and VirtualBox support as deprecated
+* Fix RecursionError with invalid credentials. Fixes #3374
+* Allow raw images by default. Fixes https://github.com/GNS3/gns3-server/issues/2097
+* Dot not allow "no border" style for line items
+* Use "none" for solid line style in drawing items
+* Fix editing Docker container config generates exception and empty config. Fixes #3371
+* Fix cannot detect images by default when trying to upload them in the Image Manager. Fixes #3367
+* Fix unable to set VNC console resolution. Fixes  #3365
+* Set default symbol theme to "Affinity-square-blue"
+* Fix creating a custom Ethernet switch template
+* Update decorative symbols (for Wizards etc.)
+* Use generic symbol names
+* Set raw image param when uploading an image from the appliance wizard
+* Fix incorrect param in getCompute()
+* Checks for valid hostname on server side for Dynamips, IOU, Qemu and Docker nodes
+* Fix incorrect call to QProgress.setValue() with float
+* Reactivate project importation
+* Support compression levels
+* Add zstandard compression
+* Upgrade dependencies
+* Remove Qemu binary requirement
+* Use controller API to list images
+* Use new API endpoints to create/resize Qemu disk images.
+* Drop Python 3.6 support and require Python >= 3.7
+* Improvements when connecting and updating computes
+* Use current directory when searching for images. Fixes #3198
+* Refactor server settings and wizard
+* Disable local server and GNS3 VM preferences
+* Image uploading to controller and project export
+* HTTP client refactoring completed
+* Start HTTP client refactoring
+* Upgrade dependencies
+* Handle empty compute_id in preferences. Ref #3265
+* Remove direct upload to compute
+* Send JWT token in query string when connecting to websocket. Ref https://github.com/GNS3/gns3-server/pull/1992
+* Option to delete orphaned image files from disk when template is removed. Fixes #3249
+* Remove Qemu legacy networking code
+* Isolate and unisolate support. Fixes https://github.com/GNS3/gns3-gui/issues/3190
+* Support authentication using JWT tokens
+* Change Qemu disk descriptions. Fixes #3035
+* Edit only text mode config files
+* Hide config import/export when configFiles attribute is empty
+* Qemu disk interfaces must be set to "none" by default. Ref #3035
+* Do not allow image to be configured on Qemu VM secondary slave disk if create config disk option is enabled.
+* Add explicit option to automatically create or not the config disk. Off by default.
+* Auxiliary console support for Qemu. Ref #2873 Improvements for auxiliary console support for Docker and Dynamips.
+* Support to reset all console connections. Ref https://github.com/GNS3/gns3-server/issues/1619
+* Support to reset links. Fixes https://github.com/GNS3/gns3-server/issues/1620
+* Fix bug when recent files cannot be seen in the new project dialog.
+* Wait for the controller to be online before allowing actions like creating or opening a project. Fixes #2907
+* Show progress dialog immediately when connecting to server. Ref #2907
+* QEMU config disk - enable QEMU config import/export
+* Add total RAM, CPUs and disk size to servers summary as well as disk usage in percent. Fixes https://github.com/GNS3/gns3-server/issues/1532
+* Resource constraints for Docker VMs.
+* Wait for readme to be updated before exporting the project.
+* Support for "usage" for "Cloud" nodes. Fixes https://github.com/GNS3/gns3-gui/issues/2887 Allow "usage" for all builtin nodes (not exposed in Ui).
+
+## 2.2.43 19/09/2023
+
+* Add KiTTY to preconfigured telnet consoles. Fixes #3507
+* Fix generic icon in Wayland. Ref #3501
+* Support for appliance format version 8.
+* Use importlib instead of pkg_resources
+* Upgrade to PyQt 5.15.9 and pywin32
+* Add support for appliance version 8 format
+
+## 2.2.42 09/08/2023
+
+* Use the system's certificate store for SSL connections
+* Give a node some time to start before opening the console (for console auto start). Fixes #3474
+* Use Mate Terminal by default if installed on Debian, Ubuntu and Linux Mint.
+* Support for gnome-terminal tabs to be opened in the same window.
+* Remove import urllib3 and let sentry_sdk import and patch it. Fixes https://github.com/GNS3/gns3-gui/issues/3498
+* Add import sys in sudo.py
+* Rounded Rectangle support
+
+## 2.2.41 12/07/2023
+
+* Use alternative method to set the correct permissions for uBridge on macOS
+* Remove sending stats to GA
+* Catch urllib3 exceptions when sending crash report. Ref https://github.com/GNS3/gns3-gui/issues/3483
+* Backport UEFI boot mode support for Qemu VMs
+* Add debug for dropEvent. Ref https://github.com/GNS3/gns3-server/issues/2242
+
+## 2.2.40.1 10/06/2023
+
+* No changes
+
+## 2.2.40 06/06/2023
+
+* Change log messages for Websocket errors
+* Do not proceed if an appliance symbol cannot be downloaded. Ref #3466
+* Delete a node or link from topology summary view using Delete key. Ref #3445
+* Fix "Start the capture visualization program" checkbox works only one (first) time for a given link. Fixes #3442
+* Let the selected link style applied when editing a link. Fixes #3460
+* Fix hovered color shown in style editing dialog. Fixes #3460
+
+## 2.2.39 08/05/2023
+
+* Fix nodes are not snapped to the grid at the moment of creation
+* Upgrade distro and aiohttp dependencies
+
+## 2.2.38 28/02/2023
+
+* Add long description content type in setup.py
+* Automatically add new issues to GNS3 project
+* Development 2.2.38.dev1
+
+## 2.2.37 25/01/2023
+
+* Upgrade to PyQt5 v5.15.7
+* Changed Windows Terminal telnet console profile from OS X to windows ref: issue #3193
+
+## 2.2.36 04/01/2023
+
+* Add Trusted Platform Module (TPM) support for Qemu VMs
+* Add "on_close" setting to appliance schema. Fixes https://github.com/GNS3/gns3-server/issues/2148
+* Add default 'ide' disk interface when manually creating Qemu VM template. Fixes #3360
+* Fix zoom factor is multiplied when loading projects. Fixes #3408
+* Remove deprecated PuTTY option in preferences. Ref https://github.com/GNS3/gns3-gui/discussions/3415
+
+
+## 3.0.0a3 27/12/2022
+
+* Catch timeout error while updating appliance files
+* Fix RecursionError with invalid credentials. Fixes #3374
+* Allow raw images by default. Fixes https://github.com/GNS3/gns3-server/issues/2097
+* Remove deprecated PuTTY option in preferences. Ref https://github.com/GNS3/gns3-gui/discussions/3415
+* Fix "variables": [] in project file leads to unlimited increase of empty name/value pairs in GUI. Fixes #3397
+* Ignore local revision when comparing versions.
+* Make version PEP 440 compliant
+* Support for Python 3.11
+* Replace deprecated distro.linux_distribution() call
+* Add a fix for the CVE-2007-4559
+
+
+## 2.2.35.1 10/11/2022
+
+* Re-release Web-Ui v2.2.35
+
+## 2.2.35 08/11/2022
+
+* Fix "variables": [] in project file leads to unlimited increase of empty name/value pairs in GUI. Fixes #3397
+* Make version PEP 440 compliant
+* Support for Python 3.11
+* Upgrade PyQt to 5.15.7 and pywin32 to v305
+* Allow for more dependency versions at patch level
+* Replace deprecated distro.linux_distribution() call
+* Add a fix for the CVE-2007-4559
+
+## 3.0.0a2 06/09/2022
+
+* Add missing 'sys' module. Ref #3373
+* Upgrade dev dependencies
+* Dot not allow "no border" style for line items
+* Use "none" for solid line style in drawing items
+* Implement new option (Delete All) to contextual menu in "Console" dock. Fixes #3325
+* Fix editing Docker container config generates exception and empty config. Fixes #3371
+* Fix 2560x1440 resolution for Docker container
+* Fix cannot detect images by default when trying to upload them in the Image Manager. Fixes #3367
+* Fix unable to set VNC console resolution. Fixes  #3365
+
+## 3.0.0a1 04/08/2022
+
+* Set default symbol theme to "Affinity-square-blue"
+* Fix creating a custom Ethernet switch template
+* Update decorative symbols (for Wizards etc.)
+* Use generic symbol names
+* Set raw image param when uploading an image from the appliance wizard
+* Checks for valid hostname on server side for Dynamips, IOU, Qemu and Docker nodes
+* Support compression levels
+* Add zstandard compression
+* Remove Qemu binary requirement
+* Use controller API to list images
+* Use new API endpoints to create/resize Qemu disk images.
+* Image management dialog
+* Drop Python 3.6 support and require Python >= 3.7
+* Improvements when connecting and updating computes
+* Use current directory when searching for images. Fixes #3198
+* Refactor server settings and wizard
+* Disable local server and GNS3 VM preferences
+* Image uploading to controller and project export
+* HTTP client refactoring
+* Handle empty compute_id in preferences. Ref #3265
+* Remove direct upload to compute
+* Send JWT token in query string when connecting to websocket. Ref https://github.com/GNS3/gns3-server/pull/1992
+* Remove traceng code
+* Option to delete orphaned image files from disk when template is removed. Fixes #3249
+* Remove Qemu legacy networking code
+* Isolate and unisolate support. Fixes https://github.com/GNS3/gns3-gui/issues/3190
+* Support authentication using JWT tokens
+* Providing the path to create a project is now deprecated.
+* Client to use version 3 of the API.
+* Change Qemu disk descriptions. Fixes #3035
+* Edit only text mode config files
+* Hide config import/export when configFiles attribute is empty
+* Qemu disk interfaces must be set to "none" by default. Ref #3035
+* Do not allow image to be configured on Qemu VM secondary slave disk if create config disk option is enabled.
+* Add explicit option to automatically create or not the config disk. Off by default.
+* Auxiliary console support for Qemu. Ref #2873 Improvements for auxiliary console support for Docker and Dynamips.
+* Support to reset all console connections. Ref https://github.com/GNS3/gns3-server/issues/1619
+* Support to reset links. Fixes https://github.com/GNS3/gns3-server/issues/1620
+* Fix bug when recent files cannot be seen in the new project dialog.
+* Wait for the controller to be online before allowing actions like creating or opening a project. Fixes #2907
+* Show progress dialog immediately when connecting to server. Ref #2907
+* QEMU config disk - enable QEMU config import/export
+* Add total RAM, CPUs and disk size to servers summary as well as disk usage in percent. Fixes https://github.com/GNS3/gns3-server/issues/1532
+* Resource constraints for Docker VMs.
+* Support for "usage" for "Cloud" nodes. Fixes https://github.com/GNS3/gns3-gui/issues/2887 Allow "usage" for all builtin nodes (not exposed in Ui).
+* Markdown support in project Readme. Fixes #2550 #2289 Allow project README to be edited from "File->Edit project". Fixes #2829
+
+## 2.2.34 28/08/2022
+
+* Upgrade dev dependencies
+* Implement new option (Delete All) to contextual menu in "Console" dock. Fixes #3325
+* Fix 2560x1440 resolution for Docker container
+
+## 2.2.33.1 21/06/2022
+
+* Match GNS3 server version
+
+## 2.2.33 20/06/2022
+
+* Upgrade sentry-sdk and psutil
+* Check that node names for Qemu and Docker are valid
+* Backport reset all console connections. Fixes #2072
+* Add more video resolutions to Docker containers using VNC. Fixes #3329
+* Add python_requires=">=3.4" in setup.py. Fixes  #3326
+* Only allow post release corrective versions of GUI and server to interact
+* Allow minor versions of GUI and server to interact
+* Update VirtViewer path. Fixes #3334
+
+## 2.2.32 27/04/2022
+
+* Use public DSNs for Sentry
+* Fix exception when doubleclick on NAT node. Fixes #3312
+* Fix "Apply" button in the "Preferences" dialog stays gray when templates/nodes are opened by double-click. Fixes #3307
+* Add 'reset docks' in the view menu. Ref #3317
+
+## 2.2.31 26/02/2022
+
+* Install setuptools v59.6.0 when using Python 3.6
+
+## 2.2.30 25/02/2022
+
+* Set setuptools to v60.6.0
+* Upgrade to pywin32 v303. Ref #3290
+* Fix int() call. Ref #3283
+* Fix QPoint() as unexpected type 'float'. Fixes #3283
+* Fix painter.drawRect() has unexpected type 'float'. Fixes #3282
+* Fix SpinBox.setValue() requires integer. Fixes #3281
+
+## 2.2.29 08/01/2022
+
+* Clear cache when opening symbol selection dialog. Fixes #3256
+* Fix @ in username issue with HTTP authentication. Fixes #3275
+* Use '//' operator instead of int()
+* Fix create drawing item calls since mapToScene() returns a QPointF https://doc.qt.io/qt-5/qgraphicsview.html#mapToScene-4
+* Fixed QPoint called with floats
+
+## 2.2.28 15/12/2021
+
+* Fixed drawLine called with float arguments
+* Fixed dead VIX API link
+
+## 2.2.27 12/11/2021
+
+* Fix symbols in "Symbol selection" dialog are not placed in alphabetical order. Fixes #3245
+* Fix links duplicates in topology summary. Fixes #3251
+* chore : use --no-cache-dir flag to pip in dockerfiles to save space
+
+## 2.2.26 08/10/2021
+
+* Upgrade embedded Python to version 3.7 in Windows package
+* Upgrade Visual C++ Redistributable for Visual Studio 2019 in Windows package
+* Fix SSL support in Windows package
+* Open "template configuration" dialog with double click on template name in "Preferences". Fixes #3239
+* Only show "virtio" network adapter when legacy node is enabled. Fixes https://github.com/GNS3/gns3-gui/issues/1969
+* Double-click on a template opens "template configuration" dialog. Fixes #3236
+* Fix "Custom symbols" can't be unfolded after using "Filter" field. Fixes #3231
+
+## 2.2.25 14/09/2021
+
+* Fix menu disabled for modal dialogs on macOS. Fixes #3007
+* Change method to display the recent files menu. Fixes #3007
+* Fix bug when using empty port names for custom adapters. Fixes #3228
+* Upgrade Qt to version 5.15.4 on macOS
+* Fix mouse zoom-in/out step value is two times bigger than keyboard one. Fixes #3226
+* Upgrade to Qt 5.15.4 on Windows. Ref #3210
+* Fix issue with custom adapters at the node level. Fixes #3223
+* Explicitly require setuptools, utils/get_resource.py imports pkg_resources
+
+## 2.2.24 25/08/2021
+
+* Fix incorrect Qemu binary selected when importing template. Fixes https://github.com/GNS3/gns3-gui/issues/3216
+* Early support for Python3.10
+* Bump pywin32 from 300 to 301
+* Add PyQt5==5.12.3 for macOS build
+
+## 2.2.23 05/08/2021
+
+* Handle -no-kvm param deprecated in Qemu >= v5.2
+* Support for invisible links. Fixes #2461
+* Add kitty console application command line. Fixes #3203
+* Add Windows Terminal profile as an option for Console Applications. Fixes #3193
+
+## 2.2.22 10/06/2021
+
+* Fix exception shown when GNS3 is started with empty config. Fixes #3188
+* Add ZOC8 console terminal for macOS command line
+* Link style support. Fixes https://github.com/GNS3/gns3-gui/issues/2461
+* Fix charcoal theme. Ref #3137
+* Fix issue when showing menu to select port. Fixes #3169
+
+## 2.2.21 10/05/2021
+
+* Fix issue with empty project variable name. Fixes #3162
+* Downgrade to PyQt5 5.12.1. Fixes https://github.com/GNS3/gns3-gui/issues/3169
+
+## 2.2.20 09/04/2021
+
+* Fix project does not load anymore. Fixes #3140
+* Do not connect to server while waiting for user to accept/reject SSL certificate. Fixes #3144
+* Fix invalid server version check request. Fixes #3144
+* Upgrade dependencies
+* Add terminator as a predefined custom console option
+
+## 2.2.19 05/03/2021
+
+* No changes
+
+## 2.2.18 16/02/2021
+
+* SSL support.
+* Remove the useless file "zoom-in (copy).svg". Fixes #3114
+* Use HDD disk image as startup QEMU config disk
+* Edit only text mode config files
+* Hide config import/export when configFiles attribute is empty
+* Qemu disk interfaces must be set to "none" by default. Ref #3035
+* Do not allow image to be configured on Qemu VM secondary slave disk if create config disk option is enabled.
+* Add explicit option to automatically create or not the config disk. Off by default.
+* QEMU config disk support
+
+## 2.2.17 04/12/2020
+
+* Remove "-nographic" option by default for Qemu VM. Fixes #3094
+* Fix app cannot start on macOS Big Sur. Ref #3037
+* Require confirmation before stopping all devices.
+
+## 2.2.16 05/11/2020
+
+* Fix packets capture stops after some time. Fixes #3067
+* Option to allocate or not the vCPUs and RAM settings for the GNS3 VM. Fixes https://github.com/GNS3/gns3-gui/issues/3069
+
+## 2.2.15 07/10/2020
+
+* Fix custom symbol not sent to remote controller when installing appliance
+
+## 2.2.14 14/09/2020
+
+* Improvements to add a new version of an appliance from wizard. Fixes #3002.
+
+## 2.2.13 04/09/2020
+
+* No changes
+
+## 2.2.12 07/08/2020
+
+* Downgrade psutil to version 5.6.7
+* Fix log shows the GUI command line without spaces between its arguments. Fixes #3026
+* Use server host is console host is equal to "0:0:0:0:0:0:0:0"
+* Remove VMware promotion.
+
+## 2.2.11 09/07/2020
+
+* Try to fix "Recent project" selection not working. Ref #3007
+* Fix debug entries shown twice in console window and double error messages with remote GNS3VM. Fixes #3010
+* Fix deprecation warning. Ref #3009
+* Fix tests on macOS. Ref #3009
+* Fix sentry SDK is configured twice.
+
+## 2.2.10 18/06/2020
+
+* New fix for multi-device selection/deselection not working as expected with right click. Fixes #2986
+* Optimize snap-to-grid code for drawing items. Fixes #2997
+* Move jsonschema 2.6.0 requirement in build repository.
+* Only use jsonschema 2.6.0 on Windows and macOS.
+* Disable default integrations for sentry sdk.
+
+## 2.2.9 04/06/2020
+
+* Fix GUI doesn't detect another GUI on macOS. Fixes #2994
+* Support to activate/deactive network connection state replication in Qemu.
+* Option to reset or not all MAC addresses when exporting or duplicating a project.
+* Fix Multi-device selection/deselection not working as expected with right click. Fixes #2986
+* Replace Raven by Sentry SDK. Fixes https://github.com/GNS3/gns3-server/issues/1758
+* Fix online help menu URL. Fixes #2984
+* Require setuptools>=17.1 in setup.py. Ref https://github.com/GNS3/gns3-server/issues/1751 This is to support environmental markers. https://github.com/pypa/setuptools/blob/master/CHANGES.rst#171
+* Update README. Ref https://github.com/GNS3/gns3-server/issues/1719
+* Restore editReadme attribute which was removed in Change 'New export project wizard'
+* Updated GUI pyqt files from Tab Order 'fixes' in "Tab Order in Preferences and Project Dialog #2872"
+
+## 2.2.8 07/05/2020
+
+* Default port set to 80 for server running in the GNS3 VM. Fixes #1737
+* Make the Web UI the default page. Ref https://github.com/GNS3/gns3-server/issues/1737
+* Fix "export portable project forgets contents of README". Fixes #1724
+* Activate unified title and toolbar on MacOS. Fixes #2968
+* Confirmation dialog for "console connect to all nodes". Fixes #2971
+* Add "Resume all suspended links". Fixes #2858
+* Revert "Change default path for SecureCRT. Fixes #2896"
+* Remove @property from ConfigurationDialog(). Fixes #2819 #2965
+* Use Environmental Markers to force jsonschema version. Fixes https://github.com/GNS3/gns3-gui/issues/2849 Version 3.2.0 with Python >= 3.8 Version 2.6.0 with Python < 3.8
+* Use Environmental Markers to force jsonschema version 2.6.0 on Windows/macOS. Ref https://github.com/GNS3/gns3-gui/issues/2849
+* Remove preferences dialog geometry restoration. Fixes #2807
+* Fix unable to configure custom adapters for Qemu VMs. Fixes #2961
+
+## 2.2.7 07/04/2020
+
+* Fix VNC console template doesn't extract %i (Project UUID). Fixes #2960
+* Fix contextual menu issues. Ref #2955
+
+## 2.2.6 26/03/2020
+
+* Prevent locked drawings to be deleted. Fixes https://github.com/GNS3/gns3-gui/issues/2948
+* Fix issues with empty project variables. Fixes https://github.com/GNS3/gns3-gui/issues/2941
+* Upgrade psutil to version 5.6.6 due to CVE-2019-18874 https://github.com/advisories/GHSA-qfc5-mcwq-26q8
+* Use existing README.txt if existing when exporting portable project. Fixes https://github.com/GNS3/gns3-server/issues/1724
+* Allow creation of a diskless Qemu VMs. Fixes #2939
+* Re-enable "create new version" in appliance wizard. Fixes #2837
+* Fix unable to load project from project library. Fixes #2932
+* Fix some permission denied errors when loading remote project. Ref #2871 Fixes #2901
+* Add 'Royal TS V5' to predefined console list
+* Disallow invalid grid sized. Fixes #2908
+* Check if hostname is blank. Fixes #2924
+* Add nvme disk interface and fix scsi disk interface for Qemu VMs.
+* Add latest Qemu nic models.
+* Upgrade Qt version to 5.14.1. Ref #2778 #2903
+
+## 2.2.5 09/01/2020
+
+* Add gns3-gui.xml and update Linux icons paths & permissions. Ref #2919
+
+## 2.2.4 08/01/2020
+
+* Fix "Console to all nodes" doesn't open cloud objects with console configured. Fixes #2902
+* Change default path for SecureCRT. Fixes #2896
+* Add icons in setup.py Ref #2898
+* Add remote viewer as a VNC console for Linux. Fixes #2913
+
+## 2.2.3 12/11/2019
+
+* Fix issue when binding on 0.0.0.0. Fixes #2892
+* Allow double click on cloud with configured console to open session. Fixes #2894
+* Officially support Python 3.8. Ref https://github.com/GNS3/gns3-gui/issues/2895
+* Set psutil to version 5.6.3 in requirements.txt
+
+## 2.2.2 04/11/2019
+
+* Fix KeyError: 'spice+agent'. Fixes #2890
+* Fix wrong log.error() call when exporting file.
+* Revert "Explicitly cleanup the cache directory."
+* Fix "UnboundLocalError: local variable 'pywintypes' referenced before assignment"
+* Fix GUI uses only telnet console. Fixes #2885
+* Fix missing sys module in sudo.py Fixes #2886
+
+## 2.2.1 01/11/2019
+
+* Check if console_type is None.
+* Explicitly cleanup the cache directory.
+* Get Windows interface from registry if cannot load win32com module.
+* Ignore OSError returned by psutil when bringing console to front.
+* Catch error if NPF or NPCAP service cannot be detected. Ref https://github.com/GNS3/gns3-server/issues/1670
+* Better handling for reading synchronous JSON response from server. Ref #2874
+* Fix JSONDecodeError when getting server version. Fixes #2874
+* Fix FileNotFoundError exceptions when launching SPICE or VNC clients.
+* Fix UnboundLocalError local variable 'win32serviceutil' referenced before assignment
+* 'Fix' tab order in preferences dialog so it follows the layout
+* 'Fix' tab order in edit project dialog so it follows the layout
+* Use compatible shlex_quote to handle case where Windows needs double quotes around file names, not single quotes. Ref https://github.com/GNS3/gns3-gui/issues/2866
+* Use 0.0.0.0 by default for server host. Fixes https://github.com/GNS3/gns3-server/issues/1663
+* Catch IndexError when configuring port names. Fixes #2865
+
+## 2.2.0 30/09/2019
+
+* No changes
+
+## 2.2.0rc5 09/09/2019
+
+* Adjust size for setup dialog and remove question about running the wizard again. Ref #2846
+
+## 2.2.0rc4 30/08/2019
+
+* Fix issue when asking to run the setup wizard again. Ref #2846
+* Remove warning about VirtualBox not supporting nested virtualization. Ref https://github.com/GNS3/gns3-server/issues/1610
+* Ask user if they want to see the wizard again. Ref #2846
+
+## 2.2.0rc3 12/08/2019
+
+* Revert to jsonschema 2.6.0 due to packaging problem.
+
+## 2.2.0rc2 10/08/2019
+
+* Bump jsonschema to version 3.0.2
+* Fix "Unable to change Remote Main Server IP". Fixes #2823
+* Fix "AttributeError: 'QGraphicsTextItem' object has no attribute 'locked'". Fixes #2814
+* Fix a minor typo in the setup wizard
+
+## 2.2.0b4 11/07/2019
+
+* Fix issue preventing to open the QFileDialog in the correct directory.
+* Remove unused edit readme action. Fixes #2816
+* Remove deprecated Qemu parameter to run legacy ASA VMs. Fixes #2827
+* Upload images on remote controller. Fixes #2828
+* Preferences dialog: send API request only if connected to controller
+* Fix AttributeError: 'QGraphicsTextItem' object has no attribute 'locked'. Fixes #2814
+* Fix KeyError: 'chassis' when converting old IOS templates. Fixes #2813
+
+## 2.2.0b3 15/06/2019
+
+* Fix template migration issues from GUI to controller. Fixes https://github.com/GNS3/gns3-gui/issues/2803
+* %guest-cid% variable implementation for Qemu VMs. Fixes https://github.com/GNS3/gns3-gui/issues/2804
+* Increase timeout from 2 to 5 seconds for synchronous check. Ref #2805
+
+## 2.2.0b2 29/05/2019
+
+* Fix KeyError: 'endpoint' issue. Fixes #2802
+* Fix wrong aligment of symbols in saved/exported projects. Fixes #2800
+* Replace urllib.request by Qt implementation for local server synchronous check. Fixes #2793
+* Support snapshots for portable projects. Fixes https://github.com/GNS3/gns3-gui/issues/2792
+* Fix event notification problem for projects and how snapshots are restored.
+* Do not close the nodes dock widget when creating project.
+* Fix no scan for images on remote controller. Fixes #2799
+* Use QNetworkAccessManager to download custom appliance symbols.
+* Experimental auto upgrade should not be available for "frozen" app. Fixes #2797
+* Don't allow link labels to be moved for locked nodes. Fixes #2794
+* Catch more OSError/PermissionError when checking md5 on remote images. Fixes #2582
+* Fix exception when grid size is 0. Fixes #2790
+* Catch PermissionError when scanning local image directories. Fixes #2791
+
+## 2.1.20 29/05/2019
+
+* Fix KeyError: 'endpoint' issue. Fixes #2802
+
+## 2.1.19 28/05/2019
+
+* Fix wrong aligment of symbols in saved/exported projects. Fixes #2800
+* Replace urllib.request by Qt implementation for local server synchronous check. Fixes #2793
+* Set grid's minimum to 5. Fixes #2795
+
 ## 2.1.18 22/05/2019
 
 * Fix error in HTTPConnection.request for Python3.6. Fixes #2793
@@ -8,10 +761,32 @@
 * Catch PermissionError when scanning local image directories. Fixes #2791
 * Revert "Make sure the latest PyQt5 version 5.12.x is used on Windows." Ref #2778
 
+## 2.2.0b1 21/05/2019
+
+* Change behavior when an IOU license is verified. Fixes https://github.com/GNS3/gns3-server/issues/1555
+* Fix cannot load new profile. Fixes #2784
+* Fix remote packet capture when controller is also remote. Fixes #2785
+* Set console type to "none" by default for Ethernet switches and add a warning if trying to use "telnet". Fixes https://github.com/GNS3/gns3-gui/issues/2776
+* Add tooltip for symbol theme support in general preferences. Fixes #2770
+* Support for persistent docker volumes
+
 ## 2.1.17 17/05/2019
 
 * No changes.
 
+## 2.2.0a5 15/04/2019
+
+* Revert "Drop old Qemu support (Windows and macOS) and legacy ASA support." Ref https://github.com/GNS3/gns3-server/issues/1579
+* Do not make NPF or NPCAP service mandatory to start the local server on Windows.
+* Do not try to upload a local image that is already installed on the local server.
+* Back to the major.minor version for config files. Ref https://github.com/GNS3/gns3-gui/issues/2756
+* Some adjustments with compute WebSocket handling. Ref https://github.com/GNS3/gns3-server/issues/1564
+* Fix AttributeError: 'GraphicsView' object has no attribute '_import_config_dir'. Fixes #2768
+* Do not try to lock a SvgIconItem. Fixes #2766
+* Prevent locked nodes to be deleted. Fixes https://github.com/GNS3/gns3-gui/issues/2764
+* Add PuTTY 0.71 and mark GNS3 PuTTY as deprecated. Fixes #2758
+* Fix bug with IOS platform detection. Fixes #2760
+
 ## 2.1.16 15/04/2019
 
 * Do not make NPF or NPCAP service mandatory to start the local server on Windows.
@@ -25,6 +800,135 @@
 
 * No changes on the GUI.
 
+## 2.2.0a4 05/04/2019
+
+* Use the full version number for path to config files. Ref https://github.com/GNS3/gns3-gui/issues/2756
+* Fix error message when shutting down GUI without a started server.
+* Fix remote packet capture and make sure packet capture is stopped when deleting an NIO. Fixes https://github.com/GNS3/gns3-gui/issues/2753
+* Store config files in version specific location
+* Update pytest from 4.3.1 to 4.4.0
+* Fix error messages on closing GNS3 application. Fixes https://github.com/GNS3/gns3-gui/issues/2750
+* Fix bug when list of files for an appliance is not displayed.
+* Update 'local' to 'bundled' in server & gui, Fixes: #1561
+
+## 2.2.0a3 25/03/2019
+
+* Fix bug when changing symbol. Fixes #2740
+* Fix issue when images are not uploaded from appliance wizard. Ref https://github.com/GNS3/gns3-gui/issues/2738
+
+## 2.2.0a2 14/03/2019
+
+* Try to handle stacked widget layout differently. Ref #2605
+* Early support for symbol themes.
+* Download custom appliance symbols from GitHub Fix symbol cache issue. Ref https://github.com/GNS3/gns3-gui/issues/2671 Fix temporary directory for symbols was not deleted Fix temporary appliance file was not deleted
+* New export project wizard.
+* Update paths for binaries moved to the MacOS directory in GNS3.app
+* Prevent to change layer position for locked items. Ref #2679
+* Display available appliances in a hierarchical folder structure. Fixes #2702
+* Handle locking/unlocking items independently from the layer position.
+* Better description to why an appliance cannot be installed.
+* Force jsonschema dependency to 2.6.0
+* Fix broken idle-pc support. Fixes #1515
+
+## 2.2.0a1 29/01/2019
+
+* Fix default NAT interface not restored on Windows. Fixes #2681
+* Merge and improvements to the setup wizard. Fixes #2676.
+* Adjust the setup wizard (VMware image size, layouts).
+* Refactor appliance wizard.
+* Natural sorting support for custom adapters tree widget.
+* Add the word "template" to configuration dialog titles.
+* Reorder node contextual menu.
+* Option to limit the size of node symbols (activated by default). Ref #2674.
+* Resize SVG node symbol only when height is above 80px. Ref #2674 Work on str instead of binary when resizing SVG symbol.
+* Automatically resize SVG symbols that are too big. Ref #2674.
+* Bigger new template wizard.
+* Fix DeprecationWarning: invalid escape sequence. Fixes https://github.com/GNS3/gns3-gui/issues/2670
+* Use theme icons in other contextual menus. Fixes #2669
+* Change some text regarding appliance installation.
+* Handle errors when creating template from appliance.
+* Template creation from an appliance.
+* Basic support to create new template from appliance.
+* Fix race condition when trying to automatically open a console and the project is already running. Fixes #1493.
+* Fix issue with IOS c7200 templates and usage variable.
+* Add usage instructions to node tooltip. Ref #2662.
+* Smaller node info dialog.
+* New node information dialog to display general, usage and command line information. Ref https://github.com/GNS3/gns3-gui/issues/2662 https://github.com/GNS3/gns3-gui/issues/2656
+* Support "usage" field for Dynamips, IOU, VirtualBox and VMware. Fixes https://github.com/GNS3/gns3-gui/issues/2657
+* Add "new template" entry to File menu. Fixes #2658
+* Fix bug with filter in add template. Fixes #2651.
+* Fix missing method '_newApplianceActionSlot'. Fixes #2643.
+* Use "template" to name what we use to create new nodes.
+* Use project instead of topology where appropriate.
+* Make sure nothing is named "compute server".
+* Use "node" instead of "appliance" for grid support.
+* Support for differing grid sizes for appliances and drawings. Requires corresponding commit on gns3-server.
+* New projects can be created with show grid/snap to grid.
+* Disallow changing layer of a locked object. Ref #2513.
+* Cosmetic changes regarding appliances.
+* Fix issue when duplicating an appliance on GUI side.
+* Fix issue to access configuration pages for Ethernet switch and hub appliances.
+* Fix small bugs when using the new appliance management API.
+* Fix bug with custom adapters and categories for Docker VM. Fixes https://github.com/GNS3/gns3-gui/issues/2613
+* Fix bug with categories with Docker appliances.
+* Schema validation for appliance API. Ref #1427.
+* Remove generic controller settings API endpoint.
+* Fix conflict between the two websocket streams (project & controller).
+* Fix platform.linux_distribution() is deprecated. Fixes https://github.com/GNS3/gns3-gui/issues/2578
+* Allow multiple appliances to be installed. Ref #2490
+* Add more information about appliance templates.
+* New appliance wizard to install an appliance from different sources. Ref #2490
+* Redesign appliance handling part 1. Ref #2490  - Removed appliance templates from device dock  - Use new controller notification stream  - Fixed device update and remove from device dock
+* Fix "Network session error" issues. Fixes #2560.
+* Set default layer for newly created nodes to 1 and 2 for all other drawings. Ref #2513.
+* Deactivate TraceNG module
+* Main menu actions to WebUI and Light Web Interface
+* Enable TraceNG module
+* Add Solar-Putty command line. Ref #2519.
+* Fix issues when locking/unlocking items. Ref #2513.
+* Fix tests for default note font/color.
+* Console support for clouds (to connect to external devices or services). Fixes #2500.
+* Fix LabelItem tests.
+* Separate appliance font from note font. Fixes #2477.
+* Do not include spaces in link description (%d replacement) for packet analyzer command. Ref #2485.
+* Fix error when trying to open project. Fixes #2508
+* Launch packet capture analyzer command without creating pipe.
+* Streamline appliance wizard. Fixes #2224.
+* Fix "Node list view not updated when renaming or deleting appliance template". Fixes #2356.
+* Automatically resize the Custom adapters configuration dialog. Fixes #2467.
+* Change size of custom adapters configuration dialog. Ref #2467.
+* Improve node tooltips. Fixes #2462.
+* Do not activate "console auto start" by default. Ref #1910.
+* Support for console auto start. Fixes #1910
+* Add custom_adapters setting support for appliance files. Ref #2361.
+* Possibility to customize port names and adapter types for Qemu, VirtualBox, VMware and Docker. Fixes #2361. MAC addresses can customized for Qemu as well.
+* Allow to have the projects with the same name in different locations. Fixes #2380.
+* Save state feature for VirtualBox and VMware. New "On close" setting to select the action to execute when closing/stopping a Qemu/VirtualBox/VMware VM.
+* Support for suspend to disk / resume (Qemu). Ref #725.
+* Fix bug with 'none' console type for Ethernet switch. Fix some tests related to traceng.
+* Allow to resize a Qemu VM disk (extend only). Ref #2382.
+* Allow to select the default NAT interface in preferences for local server.
+* Fix missing lock and unlock icons in resources.
+* Consistent icon styles for contextual menu. Fixes #1272.
+* Spice with agent support for Qemu VMs. Fixes #2355.
+* Fix zoom-in zoom-out step values. Ref #2457.
+* Support for console type "none" for all VMs. Fixes #2452.
+* Allow to copy Dynamips, IOU, Qemu and Docker templates in preferences. Fixes #2451.
+* Support for none console type (Qemu & Docker only)
+* Support Qemu with HAXM acceleration.
+* Use PyQt 5.10 and change AV build to use MSVS2017
+* PyQt5.10 support, Ref. #2434
+* Allow to accept a different md5 hash than the one in the appliance file. Ref. server#1246
+* Critical information during upload file with different md5, Ref. #1246
+* Restore locked item state.
+* Bump to version 2.2.0dev1 & refresh resources/ui files.
+* Have the contextual menu use icons from the active style. Ref #1272.
+* Individually lock or unlock an item on the scene. Fixes #1228.
+* Improve lock and unlock all items so some actions can still be performed on objects. Fixes #1134.
+* Lock or unlock all items button. Fixes #1134.
+* Move console to all devices icon after the separation bar. Ref #1272
+* Lock icons. Ref #1134.
+
 ## 2.1.14 27/02/2019
 
 * Better description to why an appliance cannot be installed.

COPYING

@@ -1,504 +0,0 @@
-GNU Public License (GPL)
-------------------------
-
-  GNS3 is released under the GPLv3 (see LICENSE) with the additional
-  exemption that compiling, linking, and/or using OpenSSL is allowed.
-
-GNS3 trademark
---------------
-
-  "GNS3" is a trademark of GNS3 Technologies, Inc.
-
-Windows Driver Kit
-------------------
-
-  The Windows binary distribution includes devcon.exe, a Microsoft(R)
-  Windows Driver Kit (WDK) sample in object code form which is
-  redistributed under the terms of the WDK License terms.
-
-  With respect to binaries built using the Microsoft(R) Windows
-  Driver Kit (WDK), GPLv3 does not extend to any WDK Distributable Code.
-  All WDK Distributable Code is considered by the licensors of GNS3
-  to constitute, or be equivalent to, "System Libraries" as defined in
-  section 1 of GPLv3.
-
-OpenSSL License
----------------
-
-  The OpenSSL toolkit stays under a dual license, i.e. both the conditions of
-  the OpenSSL License and the original SSLeay license apply to the toolkit.
-  See below for the actual license texts. Actually both licenses are BSD-style
-  Open Source licenses. In case of any license issues related to OpenSSL
-  please contact openssl-core@openssl.org.
-
-/* ====================================================================
- * Copyright (c) 1998-2003 The OpenSSL Project.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in
- *    the documentation and/or other materials provided with the
- *    distribution.
- *
- * 3. All advertising materials mentioning features or use of this
- *    software must display the following acknowledgment:
- *    "This product includes software developed by the OpenSSL Project
- *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
- *
- * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
- *    endorse or promote products derived from this software without
- *    prior written permission. For written permission, please contact
- *    openssl-core@openssl.org.
- *
- * 5. Products derived from this software may not be called "OpenSSL"
- *    nor may "OpenSSL" appear in their names without prior written
- *    permission of the OpenSSL Project.
- *
- * 6. Redistributions of any form whatsoever must retain the following
- *    acknowledgment:
- *    "This product includes software developed by the OpenSSL Project
- *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
- *
- * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
- * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
- * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY 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.
- * ====================================================================
- *
- * This product includes cryptographic software written by Eric Young
- * (eay@cryptsoft.com).  This product includes software written by Tim
- * Hudson (tjh@cryptsoft.com).
- *
- */
-
- Original SSLeay License
- -----------------------
-
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
- *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- *
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- *
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- *
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY 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.
- *
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.]
- */
-
-=====================================================================================================
-Several fantastic pieces of free and open-source software have really get GNS3 to  where it is today.
-A few require that we include their license agreements within our software.
-=====================================================================================================
-
-License notice for Qt
----------------------
-http://doc.qt.io/qt-4.8/gpl.html
-
-License notice for PyQt
------------------------
-http://www.gnu.org/licenses/gpl.html
-
-License notice for jsonschema
------------------------------
-https://github.com/Julian/jsonschema/blob/master/COPYING
-
-Copyright (c) 2013 Julian Berman
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
-License notice for aiohttp
---------------------------
-https://github.com/KeepSafe/aiohttp/blob/master/LICENSE.txt
-
-Copyright (c) 2013, 2014, 2015 Nikolay Kim and Andrew Svetlov
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
-License notice for Jinja
-------------------------
-https://github.com/KeepSafe/aiohttp/blob/master/LICENSE.txt
-
-Copyright (c) 2009 by the Jinja Team, see AUTHORS for more details.
-
-Some rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-
-    * Redistributions in binary form must reproduce the above
-      copyright notice, this list of conditions and the following
-      disclaimer in the documentation and/or other materials provided
-      with the distribution.
-
-    * The names of the contributors may not be used to endorse or
-      promote products derived from this software without specific
-      prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-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 raven
-------------------------
-https://github.com/getsentry/raven-python/blob/master/LICENSE
-
-Copyright (c) 2015 Functional Software, Inc and individual contributors.
-
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-
-    * Redistributions in binary form must reproduce the above
-      copyright notice, this list of conditions and the following
-      disclaimer in the documentation and/or other materials provided
-      with the distribution.
-
-    * The names of the contributors may not be used to endorse or
-      promote products derived from this software without specific
-      prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-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 pywin32
---------------------------
-https://github.com/SublimeText/Pywin32/blob/master/License.txt
-
-Unless stated in the specfic source file, this work is
-Copyright (c) 1996-2008, Greg Stein and Mark Hammond.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-
-Redistributions of source code must retain the above copyright notice,
-this list of conditions and the following disclaimer.
-
-Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the distribution.
-
-Neither names of Greg Stein, Mark Hammond nor the name of contributors may be used
-to endorse or promote products derived from this software without
-specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
-IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR
-CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 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 Winpcap
---------------------------
-https://www.winpcap.org/misc/copyright.htm
-
-Copyright (c) 1999 - 2005 NetGroup, Politecnico di Torino (Italy).
-Copyright (c) 2005 - 2010 CACE Technologies, Davis (California).
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-
-    * Redistributions in binary form must reproduce the above
-      copyright notice, this list of conditions and the following
-      disclaimer in the documentation and/or other materials provided
-      with the distribution.
-
-    * The names of the contributors may not be used to endorse or
-      promote products derived from this software without specific
-      prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-
-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 2
-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, write to the Free Software
-Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-(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 cpulimit
----------------------------
-https://github.com/opsengine/cpulimit/blob/master/LICENSE
-
-Copyright (C) 2005-2012, by:  Angelo Marletta <angelo dot marletta at gmail dot com>
-
-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 2
-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, write to the Free Software
-Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-License notice for Cygwin
--------------------------
-https://cygwin.com/licensing.html
-
-License notice for SuperPutty
------------------------------
-https://github.com/jimradford/superputty/blob/master/License.txt
-
-Copyright (c) 2009 Jim Radford http://www.jimradford.com
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
-License notice for Putty
-------------------------
-http://www.chiark.greenend.org.uk/~sgtatham/putty/licence.html
-
-PuTTY is copyright 1997-2015 Simon Tatham.
-
-Portions copyright Robert de Bath, Joris van Rantwijk, Delian Delchev, Andreas Schultz, Jeroen Massar,
-Wez Furlong, Nicolas Barry, Justin Bradford, Ben Harris, Malcolm Smith, Ahmad Khalifa, Markus Kuhn,
-Colin Watson, Christopher Staite, and CORE SDI S.A.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
-License notice for iouyap
--------------------------
-https://github.com/GNS3/iouyap/blob/master/LICENSE
-
-License notice for Dynamips
----------------------------
-https://github.com/GNS3/dynamips/blob/master/COPYING
-
-License notice for Qemu
------------------------
-http://wiki.qemu.org/License
-
-License notice for VPCS
------------------------
-
-Copyright (c) 2007-2013, Paul Meng (mirnshi@gmail.com)
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-
-1. Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY 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 Python
--------------------------
-https://www.python.org/download/releases/3.4.2/license/
-
-License notice for BusyBox
----------------------------
-BusyBox is distributed under version 2 of the General Public License
-https://busybox.net/license.html
-
-Source code is available here:
-https://github.com/GNS3/busybox
-
-
-Licence notice for zipstream
------------------------------
-zipstream is distributed under version 3 of the General Public License
-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,22 +1,16 @@
 # Run tests inside a container
-FROM ubuntu:17.10
-
+FROM ubuntu:latest
 MAINTAINER GNS3 Team
 
-#ENV DEBIAN_FRONTEND noninteractive
-
 RUN apt-get update
-RUN apt-get install -y --force-yes python3.6 python3-pyqt5 python3-pip python3-pyqt5.qtsvg python3-pyqt5.qtwebsockets python3.6-dev xvfb
+RUN apt-get install -y --force-yes python3 python3-pyqt5 python3-pip python3-pyqt5.qtsvg python3-pyqt5.qtwebsockets python3-dev xvfb
 RUN apt-get clean
 
-
 ADD dev-requirements.txt /dev-requirements.txt
 ADD requirements.txt /requirements.txt
-RUN pip3 install -r /dev-requirements.txt
-
+RUN python3 -m pip install --break-system-packages --no-cache-dir -r /dev-requirements.txt
 
 ADD . /src
-
 WORKDIR /src
 
-CMD xvfb-run python3.6 -m pytest -vv
+CMD xvfb-run python3 -m pytest -vv

MANIFEST.in

@@ -1,11 +1,6 @@
-include README.rst
-include AUTHORS
+include README.md
 include LICENSE
-include MANIFEST.in
-include requirements.txt
-include tox.ini
-recursive-include tests *
+include CHANGELOG
 recursive-include gns3 *
-recursive-include resources *
 recursive-exclude * __pycache__
 recursive-exclude * *.py[co]

README.md

@@ -0,0 +1,58 @@
+GNS3-gui
+========
+
+[![GitHub Actions tests](https://github.com/GNS3/gns3-gui/workflows/testing/badge.svg)](https://github.com/GNS3/gns3-gui/actions?query=workflow%3Atesting)
+[![Latest PyPi version](https://img.shields.io/pypi/v/gns3-gui.svg)](https://pypi.python.org/pypi/gns3-gui)
+[![Snyk scanning](https://snyk.io/test/github/GNS3/gns3-gui/badge.svg)](https://snyk.io/test/github/GNS3/gns3-gui)
+
+Installation
+------------
+
+Please see the documentation on our [website](https://docs.gns3.com)
+
+Software dependencies
+---------------------
+
+PyQt5 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/3.0/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
+```
+
+### Debugging
+
+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

@@ -1,47 +0,0 @@
-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
-------------
-
-Please see https://docs.gns3.com/
-
-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 issues
-----------------
-Please contact us using contact informations available here:
-http://docs.gns3.com/1ON9JBXSeR7Nt2-Qum2o3ZX0GU86BZwlmNSUgvmqNWGY/index.html
-

SECURITY.md

@@ -0,0 +1,5 @@
+# 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

appveyor.yml

@@ -1,19 +0,0 @@
-version: '{build}-{branch}'
-
-image: Visual Studio 2015
-
-platform: x64
-
-environment:
-    PYTHON: "C:\\Python36-x64"
-    DISTUTILS_USE_SDK: "1"
-
-install:
-   - cinst nmap
-   - "%PYTHON%\\python.exe -m pip install -r dev-requirements.txt"
-   - "%PYTHON%\\python.exe -m pip install -r win-requirements.txt"
-
-build: off
-
-test_script:
-   - "%PYTHON%\\python.exe -m pytest -v"

dev-requirements.txt

@@ -1,6 +1,2 @@
--rrequirements.txt
-
-pep8==1.7.0
-pytest==3.1.0
-pytest-pythonpath==0.7.1 # useful for running tests outside tox
-pytest-timeout==1.2.0
+pytest==8.3.4
+pytest-timeout==2.3.1

gns3/appliance_manager.py

@@ -17,105 +17,81 @@
 
 from .qt import QtCore
 from .controller import Controller
-from .utils.server_select import server_select
+from .local_config import LocalConfig
+from .settings import GENERAL_SETTINGS
+from .http_client_error import HttpClientError
+
 
 import logging
 log = logging.getLogger(__name__)
 
 
 class ApplianceManager(QtCore.QObject):
+    """
+    Manager for appliances.
+    """
 
     appliances_changed_signal = QtCore.Signal()
 
     def __init__(self):
+
         super().__init__()
-        self._appliance_templates = []
         self._appliances = []
         self._controller = Controller.instance()
         self._controller.connected_signal.connect(self.refresh)
         self._controller.disconnected_signal.connect(self._controllerDisconnectedSlot)
-        self.refresh()
 
-    def refresh(self):
+    def refresh(self, update=False):
+        """
+        Gets the appliances from the controller.
+        """
+
         if self._controller.connected():
-            self._controller.get("/appliances/templates", self._listApplianceTemplateCallback)
-            self._controller.get("/appliances", self._listAppliancesCallback)
+            settings = LocalConfig.instance().loadSectionSettings("MainWindow", GENERAL_SETTINGS)
+            symbol_theme = settings["symbol_theme"]
+            if update is True:
+                try:
+                    self._controller.get(
+                        "/appliances?update=yes&symbol_theme={}".format(symbol_theme),
+                        self._listAppliancesCallback,
+                        progress_text="Downloading appliances from online registry...",
+                        wait=True,
+                        timeout=300
+                    )
+                except HttpClientError as e:
+                    log.error(f"Error while getting appliances list: {e}")
+                    return
+            else:
+                self._controller.get("/appliances?symbol_theme={}".format(symbol_theme), self._listAppliancesCallback)
 
     def _controllerDisconnectedSlot(self):
-        self._appliance_templates = []
+        """
+        Called when the controller has been disconnected.
+        """
+
         self._appliances = []
         self.appliances_changed_signal.emit()
 
-    def appliance_templates(self):
-        return self._appliance_templates
-
     def appliances(self):
+        """
+        Returns the appliances.
+
+        :returns: array of appliances
+        """
+
         return self._appliances
 
-    def getAppliance(self, appliance_id):
-        """
-        Look for an appliance by appliance ID
-        """
-        for appliance in self._appliances:
-            if appliance["appliance_id"] == appliance_id:
-                return appliance
-        return None
-
     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()
 
-    def _listApplianceTemplateCallback(self, result, error=False, **kwargs):
-        if error is True:
-            log.error("Error while getting appliance templates list: {}".format(result.get("message", "unknown")))
-            return
-        self._appliance_templates = result
-        self.appliances_changed_signal.emit()
-
-    def createNodeFromApplianceId(self, project, appliance_id, x, y):
-        for appliance in self._appliances:
-            if appliance["appliance_id"] == appliance_id:
-                break
-
-        if not self._controller.connected():
-            log.error("Cannot create node: not connected to any controller server")
-            return
-
-        if not project or not project.id():
-            log.error("Cannot create node: please create a project first!")
-            return
-
-        project_id = project.id()
-        if appliance.get("compute_id") is None:
-            from .main_window import MainWindow
-            server = server_select(MainWindow.instance(), node_type=appliance["node_type"])
-            if server is None:
-                return False
-            self._controller.post("/projects/" + project_id + "/appliances/" + appliance_id, self._createNodeFromApplianceCallback, {
-                "compute_id": server.id(),
-                "x": int(x),
-                "y": int(y)
-            },
-                showProgress=False,
-                timeout=None)
-        else:
-            self._controller.post("/projects/" + project_id + "/appliances/" + appliance_id, self._createNodeFromApplianceCallback, {
-                "x": int(x),
-                "y": int(y)
-            },
-                showProgress=False,
-                timeout=None)
-        return True
-
-    def _createNodeFromApplianceCallback(self, result, error=False, **kwargs):
-        if error:
-            if "message" in result:
-                log.error("Error while creating node: {}".format(result["message"]))
-            return
-
     @staticmethod
     def instance():
         """

gns3/application.py

@@ -20,6 +20,7 @@ import sys
 
 from .qt import QtWidgets, QtGui, QtCore
 from gns3.utils import parse_version
+from gns3.local_config import LocalConfig
 from .version import __version__
 
 import logging
@@ -37,7 +38,9 @@ class Application(QtWidgets.QApplication):
             # only available starting Qt version 5.6
             if hdpi:
                 if sys.platform.startswith("linux"):
-                    log.warning("HDPI mode is enabled. HDPI support on Linux is not fully stable and GNS3 may crash depending of your version of Linux. To disabled HDPI mode please edit ~/.config/GNS3/gns3_gui.conf and set 'hdpi' to 'false'")
+                    local_config_path = LocalConfig.instance().configFilePath()
+                    log.warning("HDPI mode is enabled. HDPI support on Linux is not fully stable and GNS3 may crash depending of your version of Linux. "
+                                f"To disabled HDPI mode please edit '{local_config_path}' and set 'hdpi' to 'false'")
                 self.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling)
                 self.setAttribute(QtCore.Qt.AA_UseHighDpiPixmaps)
             else:
@@ -46,6 +49,9 @@ class Application(QtWidgets.QApplication):
 
         super().__init__(argv)
 
+        # this is tell Wayland what is the name of the desktop file (gns3.desktop)
+        self.setDesktopFileName("gns3")
+
         # this info is necessary for QSettings
         self.setOrganizationName("GNS3")
         self.setOrganizationDomain("gns3.net")

gns3/base_node.py

@@ -19,20 +19,14 @@
 Base class for node classes.
 """
 
-import os
-import pathlib
-
 from .qt import QtCore
 from .ports.port import Port
-from .utils.normalize_filename import normalize_filename
-
 
 import logging
 log = logging.getLogger(__name__)
 
 
 class BaseNode(QtCore.QObject):
-
     """
     BaseNode implementation.
 
@@ -53,7 +47,6 @@ class BaseNode(QtCore.QObject):
     server_error_signal = QtCore.Signal(int, str)
 
     _instance_count = 1
-    _allocated_names = set()
 
     # node statuses
     stopped = 0
@@ -61,14 +54,15 @@ class BaseNode(QtCore.QObject):
     suspended = 2
 
     # node categories
-    routers = 0
-    switches = 1
-    end_devices = 2
-    security_devices = 3
+    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
@@ -85,19 +79,48 @@ class BaseNode(QtCore.QObject):
 
     def links(self):
         """
-        Links connected to the node
+        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):
         """
@@ -228,59 +251,6 @@ class BaseNode(QtCore.QObject):
 
         return self._ports
 
-    @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 symbolName():
-        """
-        Returns the symbol name (for the nodes view).
-
-        :returns: name (string)
-        """
-
-        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()
-
     def controllerHttpPost(self, path, callback, body={}, context={}, **kwargs):
         """
         POST on current server / project
@@ -328,74 +298,45 @@ class BaseNode(QtCore.QObject):
 
         self._project.delete(path, callback, context=context, **kwargs)
 
-    def exportConfigToDirectory(self, directory):
+    @staticmethod
+    def defaultCategories():
         """
-        Exports the initial-config to a directory.
+        Returns the default categories.
 
-        :param directory: destination directory path
+        :returns: dict
         """
 
-        if not hasattr(self, "configFiles"):
-            return False
+        categories = {"Routers": BaseNode.routers,
+                      "Switches": BaseNode.switches,
+                      "End devices": BaseNode.end_devices,
+                      "Security devices": BaseNode.security_devices}
 
-        for file in self.configFiles():
-            self.controllerHttpGet("/nodes/{node_id}/files/{file}".format(node_id=self._node_id, file=file),
-                                   self._exportConfigToDirectoryCallback,
-                                   context={"directory": directory, "file": file},
-                                   raw=True)
+        return categories
 
-        return True
-
-    def _exportConfigToDirectoryCallback(self, result, error=False, raw_body=None, context={}, **kwargs):
+    @staticmethod
+    def defaultSymbol():
         """
-        Callback for exportConfigToDirectory.
+        Returns the default symbol path for this node.
+        Must be overloaded.
 
-        :param result: server response
-        :param error: indicates an error (boolean)
+        :returns: symbol path (or resource).
         """
 
-        if error:
-            # The file could be missing if you have not private config for example
-            return
-        export_directory = context["directory"]
+        raise NotImplementedError()
 
-        filename = normalize_filename(self.name()) + "_{}".format(context["file"].replace("/", "_"))  # We can have / in the case of Docker
-        config_path = os.path.join(export_directory, filename)
-        try:
-            with open(config_path, "wb") as f:
-                log.debug("saving {} config to {}".format(self.name(), config_path))
-                f.write(raw_body)
-        except OSError as e:
-            self.error_signal.emit(self.id(), "could not export config to {}: {}".format(config_path, e))
-
-    def importConfigFromDirectory(self, directory):
+    @staticmethod
+    def categories(self):
         """
-        Imports an initial-config from a directory.
+        Returns the node categories the node is part of (used by the device panel).
 
-        :param directory: source directory path
+        :returns: list of node category (integer)
         """
 
-        if not hasattr(self, "configFiles"):
-            return
+        raise NotImplementedError()
 
-        try:
-            contents = os.listdir(directory)
-        except OSError as e:
-            self.error_signal.emit(self.id(), "Can't list file in {}: {}".format(directory, str(e)))
-            return
+    def __str__(self):
+        """
+        Must be overloaded.
+        """
 
-        for file in self.configFiles():
-            filename = normalize_filename(self.name()) + "_{}".format(file.replace("/", "_"))  # We can have / in the case of Docker
-            if filename in contents:
-                self.controllerHttpPost("/nodes/{node_id}/files/{file}".format(
-                    node_id=self._node_id,
-                    file=file), self._importConfigCallback,
-                    pathlib.Path(os.path.join(directory, filename)))
-            else:
-                log.warning("{}: config file '{}' not found".format(self.name(), filename))
-
-    def _importConfigCallback(self, result, error=False, **kwargs):
-        if error:
-            if "message" in result:
-                log.error("Error while import config: {}".format(result["message"]))
-            return
+        raise NotImplementedError()

gns3/compute.py

@@ -20,10 +20,11 @@ import uuid
 
 class Compute:
     """
-    A compute node on the remote server
+    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
@@ -36,92 +37,230 @@ class Compute:
         self._password = None
         self._cpu_usage_percent = None
         self._memory_usage_percent = None
+        self._disk_usage_percent = None
+        self._capabilities = {"node_types": []}
         self._last_error = None
-        self._capabilities = {
-            "node_types": []
-        }
 
     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 port(self):
-        return self._port
-
-    def setPort(self, port):
-        self._port = port
-
-    def user(self):
-        return self._user
-
-    def setUser(self, user):
-        self._user = user
-
-    def setPassword(self, password):
-        self._password = password
-
-    def protocol(self):
-        return self._protocol
-
-    def setProtocol(self, protocol):
-        self._protocol = protocol
-
     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 setCpuUsagePercent(self, usage):
-        self._cpu_usage_percent = usage
+    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 setDiskUsagePercent(self, usage):
+        """
+        Sets the compute disk usage.
+
+        :returns: disk usage (integer)
+        """
+
+        self._disk_usage_percent = usage
+
+    def diskUsagePercent(self):
+        """
+        Returns the compute disk usage.
+
+        :param usage: disk usage (integer)
+        """
+
+        return self._disk_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 setCapabilities(self, val):
-        self._capabilities = val
-
     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
-        }
+
+        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

@@ -15,8 +15,7 @@
 # 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 .qt import QtCore, QtWidgets
 from .compute import Compute
 from .controller import Controller
 
@@ -31,11 +30,16 @@ 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()
@@ -43,46 +47,62 @@ class ComputeManager(QtCore.QObject):
         self._controller.disconnected_signal.connect(self._controllerDisconnectedSlot)
         self._controllerConnectedSlot()
 
-        # If we receive fresh data from the notification feed no need to refresh via an API call
+        # 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()
+        # self._timer = QtCore.QTimer()
+        # self._timer.setInterval(1000)
+        # 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)
+            self._controller.get("/computes", self._listComputesCallback, show_progress=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)
+            self._controller.get("/computes", self._listComputesCallback, show_progress=False, timeout=30)
 
     def _controllerDisconnectedSlot(self):
+        """
+        Called when disconnected from the controller.
+        """
+
         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)
+        if result:
+            for compute in result:
+                self.computeDataReceivedCallback(compute)
 
     def computeDataReceivedCallback(self, compute):
         """
-        Called when we received data from a compute
-        node.
+        Called when we received data from a compute node.
         """
 
         self._last_computes_refresh = datetime.datetime.now().timestamp()
@@ -94,15 +114,17 @@ class ComputeManager(QtCore.QObject):
             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 "connected" in compute:
+            self._computes[compute_id].setConnected(compute["connected"])
+            self._computes[compute_id].setCpuUsagePercent(compute["cpu_usage_percent"])
+            self._computes[compute_id].setMemoryUsagePercent(compute["memory_usage_percent"])
+            self._computes[compute_id].setDiskUsagePercent(compute["disk_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)
@@ -111,8 +133,9 @@ class ComputeManager(QtCore.QObject):
 
     def computeIsTheRemoteGNS3VM(self, compute):
         """
-        :returns: Boolean True if the remote server is the remote GNS3 VM
+        :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
@@ -122,6 +145,7 @@ class ComputeManager(QtCore.QObject):
         """
         :returns: List of computes nodes
         """
+
         computes = []
         for compute in self._computes.values():
             # We filter the remote GNS3 VM compute from the computes list
@@ -133,6 +157,7 @@ class ComputeManager(QtCore.QObject):
         """
         :returns: The GNS3 VM compute node or None
         """
+
         try:
             return self._computes["vm"]
         except KeyError:
@@ -142,6 +167,7 @@ class ComputeManager(QtCore.QObject):
         """
         :returns: The local compute node or None
         """
+
         try:
             return self._computes["local"]
         except KeyError:
@@ -153,6 +179,7 @@ class ComputeManager(QtCore.QObject):
 
         With a remote controller it could be different of our local platform
         """
+
         c = self.localCompute()
         if c is None:
             return sys.platform
@@ -162,31 +189,59 @@ class ComputeManager(QtCore.QObject):
         """
         :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 {} is missing.".format(compute_id))
+            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 connectToCompute(self, compute_id):
+        """
+        Connect to a compute
+        """
+
+        self._controller.post(f"/computes/{compute_id}/connect", callback=self._computeConnectCallback)
+
+    def _computeConnectCallback(self, result, error=False, **kwargs):
+
+        if error and "message" in result:
+            from gns3.main_window import MainWindow
+            parent = MainWindow.instance()
+            QtWidgets.QMessageBox.critical(parent, "Remote compute", result.get("message"))
+
     def deleteCompute(self, compute_id):
+        """
+        Deletes a compute by ID
+
+        :param compute_id: compute identifier
+        """
+
         if compute_id in self._computes:
-            compute = self._computes[compute_id]
             del self._computes[compute_id]
-            self._controller.delete("/computes/" + compute_id, None)
-        self.deleted_signal.emit(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 server with remote
+        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"]:
@@ -207,10 +262,16 @@ class ComputeManager(QtCore.QObject):
         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__())
+                params = {"connect": True}
+                self._controller.post("/computes", callback=self._computeCreatedCallback, body=compute.__json__(), params=params)
                 self._computes[compute.id()] = compute
                 self.created_signal.emit(compute.id())
 
+    def _computeCreatedCallback(self, result, error=False, **kwargs):
+
+        if error:
+            log.error(result.get("message"))
+
     @staticmethod
     def reset():
         ComputeManager._instance = None

gns3/compute_summary_view.py

@@ -16,20 +16,21 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 """
-Compute summary view that list all the compute, their status.
+Compute summary view that list all the computes and their status.
 """
 
 from .qt import QtGui, QtCore, QtWidgets
 from .compute_manager import ComputeManager
 from .topology import Topology
 from .node import Node
+from .utils import human_size
+from .utils.get_icon import get_icon
 
 import logging
 log = logging.getLogger(__name__)
 
 
 class ComputeItem(QtWidgets.QTreeWidgetItem):
-
     """
     Custom item for the QTreeWidget instance
     (topology summary view).
@@ -44,9 +45,16 @@ class ComputeItem(QtWidgets.QTreeWidgetItem):
         self._compute = compute
         self._parent = parent
         self._status = "unknown"
-
         self._refreshStatusSlot()
 
+    def getCompute(self):
+
+        return self._compute
+
+    def setCompute(self, compute):
+
+        self._compute = compute
+
     def _refreshStatusSlot(self):
         """
         Changes the icon to show the node status (started, stopped etc.)
@@ -59,14 +67,20 @@ class ComputeItem(QtWidgets.QTreeWidgetItem):
         text = self._compute.name()
 
         if self._compute.cpuUsagePercent() is not None:
-            text = "{} CPU {}%, RAM {}%".format(text, self._compute.cpuUsagePercent(), self._compute.memoryUsagePercent())
+            text = "{} CPU {}%, RAM {}%, DISK {}%".format(text,
+                                                          self._compute.cpuUsagePercent(),
+                                                          self._compute.memoryUsagePercent(),
+                                                          self._compute.diskUsagePercent())
 
         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", "")))
+            self.setToolTip(0, "Server {} v{} running on {} (CPUs={} / RAM={} / DISK={})".format(self._compute.name(),
+                                                                                                 self._compute.capabilities().get("version", "n/a"),
+                                                                                                 self._compute.capabilities().get("platform", ""),
+                                                                                                 self._compute.capabilities().get("cpus", 0),
+                                                                                                 human_size(self._compute.capabilities().get("memory", 0)),
+                                                                                                 human_size(self._compute.capabilities().get("disk_size", 0))))
             if usage is None or (self._compute.cpuUsagePercent() < 90 and self._compute.memoryUsagePercent() < 90):
                 self.setIcon(0, QtGui.QIcon(':/icons/led_green.svg'))
             else:
@@ -101,8 +115,8 @@ class ComputeItem(QtWidgets.QTreeWidgetItem):
                 self.addChild(item)
         self.sortChildren(0, QtCore.Qt.AscendingOrder)
 
-class ComputeSummaryView(QtWidgets.QTreeWidget):
 
+class ComputeSummaryView(QtWidgets.QTreeWidget):
     """
     Compute summary view implementation.
 
@@ -112,15 +126,44 @@ class ComputeSummaryView(QtWidgets.QTreeWidget):
     def __init__(self, parent):
 
         super().__init__(parent)
-
-        self._computes = {}
-
+        self._compute_items = {}
         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 contextMenuEvent(self, event):
+        """
+        Handles all context menu events.
+
+        :param event: QContextMenuEvent instance
+        """
+
+        self._showContextualMenu(event.globalPos())
+
+    def _showContextualMenu(self, pos):
+
+        item = self.currentItem()
+        if item and isinstance(item, ComputeItem):
+            compute = item.getCompute()
+            if not compute.connected():
+                menu = QtWidgets.QMenu()
+                connect_action = QtWidgets.QAction("Connect to server", menu)
+                connect_action.setIcon(get_icon("start.svg"))
+                connect_action.triggered.connect(lambda: ComputeManager.instance().connectToCompute(compute.id()))
+                menu.addAction(connect_action)
+                menu.exec_(pos)
+
+    def _computeConnectSlot(self, compute_id):
+        """
+
+        :param compute_id:
+        :return:
+        """
+
+        ComputeManager.instance().connectToCompute(compute_id)
+
     def _computeAddedSlot(self, compute_id):
         """
         Called when a compute is added to the list of computes
@@ -131,7 +174,7 @@ class ComputeSummaryView(QtWidgets.QTreeWidget):
         compute = ComputeManager.instance().getCompute(compute_id)
         if ComputeManager.instance().computeIsTheRemoteGNS3VM(compute):
             return
-        self._computes[compute_id] = ComputeItem(self, compute)
+        self._compute_items[compute_id] = ComputeItem(self, compute)
 
     def _computeUpdatedSlot(self, compute_id):
         """
@@ -140,13 +183,14 @@ class ComputeSummaryView(QtWidgets.QTreeWidget):
         :params url: URL of the compute
         """
 
-        if compute_id in self._computes:
+        if compute_id in self._compute_items:
             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()
+                self._compute_items[compute_id].setCompute(compute)
+                self._compute_items[compute_id]._refreshStatusSlot()
         else:
             self._computeAddedSlot(compute_id)
 
@@ -157,6 +201,6 @@ class ComputeSummaryView(QtWidgets.QTreeWidget):
         :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]
+        if compute_id in self._compute_items:
+            self.takeTopLevelItem(self.indexOfTopLevelItem(self._compute_items[compute_id]))
+            del self._compute_items[compute_id]

gns3/console_cmd.py

@@ -19,11 +19,11 @@
 Handles commands typed in the GNS3 console.
 """
 
+import os
 import sys
 import cmd
 import struct
 from .qt import sip
-import json
 
 from .node import Node
 from .qt import QtCore
@@ -35,6 +35,14 @@ log = logging.getLogger(__name__)
 
 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.
@@ -224,17 +232,10 @@ 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:
-                root.addHandler(logging.StreamHandler(sys.stdout))
-                if level == 1:
-                    print("Activating debugging")
-                else:
-                    print("Activating full debugging")
-                    root.setLevel(logging.DEBUG)
+                print("Activating debugging")
+                root.setLevel(logging.DEBUG)
             from .main_window import MainWindow
             MainWindow.instance().setSettings({"debug_level": level})
         else:

gns3/console_view.py

@@ -22,7 +22,7 @@ import inspect
 import datetime
 import platform
 
-from .qt import QtCore
+from .qt import QtCore, QtWidgets
 from .topology import Topology
 from .version import __version__
 from .console_cmd import ConsoleCmd
@@ -109,7 +109,33 @@ class ConsoleView(PyCutExt, ConsoleCmd):
         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 = QtWidgets.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":

gns3/controller.py

@@ -18,11 +18,17 @@
 import os
 import hashlib
 import tempfile
+import json
+import pathlib
+
+from urllib.parse import urlparse
+from .qt import QtCore, QtGui, QtWebSockets, qpartial, qslot
 
-from .qt import QtCore, QtGui, QtWidgets, qpartial, qslot
 from .symbol import Symbol
-from .local_server_config import LocalServerConfig
-from .settings import LOCAL_SERVER_SETTINGS
+from .local_config import LocalConfig
+from .settings import CONTROLLER_SETTINGS
+from gns3.utils import parse_version
+from gns3.http_client import HTTPClient
 
 import logging
 log = logging.getLogger(__name__)
@@ -30,149 +36,185 @@ log = logging.getLogger(__name__)
 
 class Controller(QtCore.QObject):
     """
-    An instance of the GNS3 server controller
+    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()
+    image_list_updated_signal = QtCore.Signal()
+
+    def __init__(self):
 
-    def __init__(self, parent=None):
         super().__init__()
         self._connected = False
         self._connecting = False
+        self._notification_stream = None
         self._version = None
-        self._cache_directory = tempfile.mkdtemp()
+        self._cache_directory = tempfile.TemporaryDirectory(suffix="-gns3")
         self._http_client = None
-        # If it's the first error we display an alert box to the user
         self._first_error = True
         self._error_dialog = None
         self._display_error = True
         self._projects = []
+        self._images = []
+        self._websocket = QtWebSockets.QWebSocket()
 
         # If we do multiple call in order to download the same symbol we queue them
         self._static_asset_download_queue = {}
 
+        self._loadSettings()
+
+    def settings(self):
+        """
+        Returns the graphics view settings.
+
+        :returns: settings dictionary
+        """
+
+        return self._settings
+
+    def _loadSettings(self):
+        """
+        Loads the settings from the persistent settings file.
+        """
+
+        self._settings = LocalConfig.instance().loadSectionSettings(self.__class__.__name__, CONTROLLER_SETTINGS)
+
+    def setSettings(self, new_settings):
+        """
+        Set new controller settings.
+
+        :param new_settings: settings dictionary
+        """
+
+        # save the settings
+        self._settings.update(new_settings)
+        LocalConfig.instance().saveSectionSettings(self.__class__.__name__, self._settings)
+
     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"]
+
+        return self._settings["remote"]
 
     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 for connected to the controller
+        :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._http_client.connected_signal.connect(self._httpClientConnectedSlot)
+            self._http_client.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 connect(self):
+        """
+        Connect to controller
+        """
+
+        self._http_client = HTTPClient(self._settings)
+        Controller.instance().setHttpClient(self._http_client)
+
     def _connectingToServer(self):
         """
         Connection process as started
         """
+
         self._connected = False
         self._connecting = True
-        self.get('/version', self._versionGetSlot)
+        self.httpClient().connectToServer()
 
     def _httpClientDisconnectedSlot(self):
+
         if self._connected:
             self._connected = False
             self.disconnected_signal.emit()
             self._connectingToServer()
-
-    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 "message" in result and self._display_error:
-                    self._error_dialog = QtWidgets.QMessageBox(self.parent())
-                    self._error_dialog.setWindowModality(QtCore.Qt.ApplicationModal)
-                    self._error_dialog.setWindowTitle("Connection to server")
-                    self._error_dialog.setText("Error when connecting to the GNS3 server:\n{}".format(result["message"]))
-                    self._error_dialog.setIcon(QtWidgets.QMessageBox.Critical)
-                    self._error_dialog.show()
-            # Try to connect again in x 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.stopListenNotifications()
 
     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.request("POST", *args, **kwargs)
 
     def get(self, *args, **kwargs):
-        return self.createHTTPQuery("GET", *args, **kwargs)
+        return self.request("GET", *args, **kwargs)
+
+    def put(self, *args, **kwargs):
+        return self.request("PUT", *args, **kwargs)
+
+    def delete(self, *args, **kwargs):
+        return self.request("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 post(self, *args, **kwargs):
-        return self.createHTTPQuery("POST", *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)
@@ -181,9 +223,10 @@ class Controller(QtCore.QObject):
         """
         Support for remote server <= 1.5
         This fix should be not require after the 2.1
-        when all the appliance template will be managed
-        on server
+        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:
@@ -192,32 +235,13 @@ class Controller(QtCore.QObject):
                 return compute_id
         return compute_id
 
-    def getEndpoint(self, path, compute_id, *args, **kwargs):
+    def request(self, method, path, *args, **kwargs):
         """
-        API post on a specific compute
+        Forward the query to the HTTP client or controller depending on the path
         """
-        compute_id = self.__fix_compute_id(compute_id)
-        path = "/computes/endpoint/{}{}".format(compute_id, path)
-        return self.get(path, *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 createHTTPQuery(self, method, path, *args, **kwargs):
-        """
-        Forward the query to the HTTP client or controller depending of the path
-        """
         if self._http_client:
-            return self._http_client.createHTTPQuery(method, path, *args, **kwargs)
-
-    def getSynchronous(self, endpoint, timeout=2):
-        return self._http_client.getSynchronous(endpoint, timeout)
-
-    def connectWebSocket(self, path, *args):
-        return self._http_client.connectWebSocket(path)
+            return self._http_client.sendRequest(method, path, *args, **kwargs)
 
     @staticmethod
     def instance():
@@ -242,7 +266,6 @@ class Controller(QtCore.QObject):
         if not self._http_client:
             return
 
-
         path = self.getStaticCachedPath(url)
 
         if os.path.exists(path):
@@ -251,9 +274,10 @@ class Controller(QtCore.QObject):
             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))
+            self._http_client.sendRequest("GET", url, qpartial(self._getStaticCallback, url, path), raw=True)
+
+    def _getStaticCallback(self, url, path, result, error=False, **kwargs):
 
-    def _getStaticCallback(self, url, path, result, error=False, raw_body=None, **kwargs):
         if path not in self._static_asset_download_queue:
             return
 
@@ -269,7 +293,7 @@ class Controller(QtCore.QObject):
             return
         try:
             with open(path, "wb+") as f:
-                f.write(raw_body)
+                f.write(result)
         except OSError as e:
             log.error("Can't write to {}: {}".format(path, str(e)))
             return
@@ -281,8 +305,8 @@ class Controller(QtCore.QObject):
     def getStaticCachedPath(self, url):
         """
         Returns static cached (hashed) path
+
         :param url:
-        :return:
         """
         m = hashlib.md5()
         m.update(url.encode())
@@ -290,9 +314,22 @@ class Controller(QtCore.QObject):
             extension = ".svg"
         else:
             extension = ".png"
-        path = os.path.join(self._cache_directory, m.hexdigest() + extension)
+        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
@@ -309,10 +346,36 @@ class Controller(QtCore.QObject):
             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),
+            progress_text="Uploading {}".format(symbol_id),
+            timeout=None,
+            wait=True
+        )
+
+    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)
 
@@ -330,6 +393,17 @@ class Controller(QtCore.QObject):
         if callback:
             callback(result, error=error, **kwargs)
 
+
+    def createDiskImage(self, disk_name, options, callback):
+        """
+        Create a disk image on the controller
+
+        :param callback: callback for the reply from the server
+        """
+
+        self.post(f"/images/qemu/{disk_name}", callback, body=options)
+
+
     @qslot
     def refreshProjectList(self, *args):
         self.get("/projects", self._projectListCallback)
@@ -341,3 +415,115 @@ class Controller(QtCore.QObject):
 
     def projects(self):
         return self._projects
+
+    @qslot
+    def refreshImageList(self, *args):
+        self.get("/images", self._imageListCallback)
+
+    def _imageListCallback(self, result, error=False, **kwargs):
+        if not error:
+            self._images = result
+        self.image_list_updated_signal.emit()
+
+    def images(self):
+        return self._images
+
+    def _startListenNotifications(self):
+        if not self.connected():
+            return
+
+        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().request(
+                "GET",
+                "/notifications",
+                self._endListenNotificationCallback,
+                download_progress_callback=self._event_received,
+                timeout=None,
+                show_progress=False
+            )
+            url = urlparse(self._http_client.url() + '/notifications')
+            log.info(f"Listening for controller notifications on {url.scheme}://{url.netloc}{url.path}")
+        else:
+            self._notification_stream = self._http_client.connectWebSocket(self._websocket, "/notifications/ws")
+            self._notification_stream.textMessageReceived.connect(self._websocket_event_received)
+            self._notification_stream.error.connect(self._websocket_error)
+            self._notification_stream.sslErrors.connect(self._sslErrorsSlot)
+            self._notification_stream.disconnected.connect(self._websocket_disconnected)
+            url = urlparse(self._notification_stream.requestUrl().toString())
+            log.info(f"Listening for controller notifications on {url.scheme}://{url.netloc}{url.path}")
+
+    def _websocket_disconnected(self):
+
+        self._connected = False
+        self.disconnected_signal.emit()
+        self.stopListenNotifications()
+
+    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()
+
+    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.stopListenNotifications()
+
+    @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

@@ -16,20 +16,19 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import sys
-import psutil
 import os
 import platform
 import struct
+import distro
 
 try:
-    import raven
-    from raven.transport.http import HTTPTransport
-    RAVEN_AVAILABLE = True
+    import sentry_sdk
+    from sentry_sdk.integrations.logging import LoggingIntegration
+    SENTRY_SDK_AVAILABLE = True
 except ImportError:
-    # raven is not installed with deb package in order to simplify packaging
-    RAVEN_AVAILABLE = False
+    # Sentry SDK is not installed with deb package in order to simplify packaging
+    SENTRY_SDK_AVAILABLE = False
 
-from .utils.get_resource import get_resource
 from .version import __version__, __version_info__
 
 import logging
@@ -51,66 +50,61 @@ class CrashReport:
     Report crash to a third party service
     """
 
-    DSN = "https://edbb50e8cb4d418ebcc647c36d5907c8:97c231cc1f1b442aabd7cf71eceda721@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))
+    DSN = "https://2c566462fd83125be9ee89bf54b546a8@o19455.ingest.us.sentry.io/38506"
     _instance = None
 
     def __init__(self):
-        # We don't want sentry making noise if an error is catched when you don't have internet
+        # We don't want sentry making noise if an error is caught when we 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
 
-    def captureException(self, exception, value, tb):
-        from .local_server import LocalServer
-        from .local_config import LocalConfig
-        from .controller import Controller
-        from .compute_manager import ComputeManager
-
-        local_server = LocalServer.instance().localServerSettings()
-        if local_server["report_errors"]:
-            if not RAVEN_AVAILABLE:
+        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))
                 return
 
-            if os.path.exists(LocalConfig.instance().runAsRootPath()):
-                log.warning("User has run application as root. Crash reports are disabled.")
-                sys.exit(1)
-                return
-
-            if os.path.exists(".git"):
-                log.warning("A .git directory exist crash report is turn off for developers. Instant exit")
-                sys.exit(1)
-                return
-
-            if hasattr(exception, "fingerprint"):
-                client = raven.Client(CrashReport.DSN, release=__version__, fingerprint=['{{ default }}', exception.fingerprint], transport=HTTPTransport)
-            else:
-                client = raven.Client(CrashReport.DSN, release=__version__, transport=HTTPTransport)
-            context = {
+            tags = {
                 "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": " ".join(platform.linux_distribution()),
+                "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 = {
                 "python:version": "{}.{}.{}".format(sys.version_info[0],
                                                     sys.version_info[1],
                                                     sys.version_info[2]),
                 "python:bit": struct.calcsize("P") * 8,
                 "python:encoding": sys.getdefaultencoding(),
-                "python:frozen": "{}".format(hasattr(sys, "frozen")),
+                "python:frozen": "{}".format(hasattr(sys, "frozen"))
             }
 
             # extra controller and compute information
-            extra_context = {"controller:version": Controller.instance().version(),
-                             "controller:host": Controller.instance().host(),
-                             "controller:connected": Controller.instance().connected()}
+            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(),
@@ -119,27 +113,48 @@ class CrashReport:
                 extra_context["compute{}:platform".format(index)] = compute.capabilities().get("platform")
                 extra_context["compute{}:version".format(index)] = compute.capabilities().get("version")
 
-            context = self._add_qt_information(context)
-            client.tags_context(context)
-            client.extra_context(extra_context)
-            try:
-                report = client.captureException((exception, value, tb))
-            except Exception as e:
-                log.error("Can't send crash report to Sentry: {}".format(e))
-                return
-            log.debug("Crash report sent with event ID: {}".format(client.get_ident(report)))
+            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
+
+            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()))
+            except Exception as e:
+                log.warning("Can't send crash report to Sentry: {}".format(e))
+
+    def _add_qt_information(self, tags):
 
-    def _add_qt_information(self, context):
         try:
             from .qt import QtCore
             from .qt import sip
         except ImportError:
-            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
+            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
 
     @classmethod
     def instance(cls):

gns3/dialogs/appliance_wizard.py

@@ -16,29 +16,35 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import os
+import sys
 from ..qt import sip
 import shutil
 
 from ..qt import QtWidgets, QtCore, QtGui, qpartial, qslot
 from ..ui.appliance_wizard_ui import Ui_ApplianceWizard
+from ..template_manager import TemplateManager
+from ..template import Template
 from ..modules import Qemu
 from ..registry.appliance import Appliance, ApplianceError
 from ..registry.registry import Registry
-from ..registry.config import Config, ConfigException
+from ..registry.config import Config
+from ..registry.appliance_to_template import ApplianceToTemplate
 from ..registry.image import Image
-from ..utils import human_filesize
+from ..utils import human_size
 from ..utils.wait_for_lambda_worker import WaitForLambdaWorker
 from ..utils.progress_dialog import ProgressDialog
 from ..compute_manager import ComputeManager
 from ..controller import Controller
 from ..local_config import LocalConfig
 from ..image_upload_manager import ImageUploadManager
+from ..image_manager import ImageManager
 
 import logging
 log = logging.getLogger(__name__)
 
 
 class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
+
     images_changed_signal = QtCore.Signal()
     versions_changed_signal = QtCore.Signal()
 
@@ -46,35 +52,62 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
         super().__init__(parent)
 
         self.setupUi(self)
-        self.images_changed_signal.connect(self._refreshVersions)
-        self.versions_changed_signal.connect(self._versionRefreshedSlot)
-
         self._refreshing = False
-
+        self._template_created = False
         self._path = path
-        # Count how many images are curently uploading
+
+        # count how many images are being uploaded
         self._image_uploading_count = 0
 
+        # symbols loaded from controller
+        self._symbols = []
+
+        # connect slots
+        self.images_changed_signal.connect(self._refreshVersions)
+        self.versions_changed_signal.connect(self._versionRefreshedSlot)
+        self.uiRefreshPushButton.clicked.connect(self.images_changed_signal.emit)
+        self.uiDownloadPushButton.clicked.connect(self._downloadPushButtonClickedSlot)
+        self.uiImportPushButton.clicked.connect(self._importPushButtonClickedSlot)
+        self.uiApplianceVersionTreeWidget.currentItemChanged.connect(self._applianceVersionCurrentItemChangedSlot)
+        self.uiCreateVersionPushButton.clicked.connect(self._createVersionPushButtonClickedSlot)
+        self.allowCustomFiles.clicked.connect(self._allowCustomFilesChangedSlot)
+
+        # directories where to search for images
         images_directories = list()
+
+        # add the current directory
+        if hasattr(sys, "frozen"):
+            images_directories.append(os.path.dirname(os.path.abspath(sys.executable)))
+        else:
+            images_directories.append(os.path.abspath(os.curdir))
+
+        for emulator in ("QEMU", "IOU", "DYNAMIPS"):
+            emulator_images_dir = ImageManager.instance().getDirectoryForType(emulator)
+            if os.path.exists(emulator_images_dir):
+                images_directories.append(emulator_images_dir)
+
         images_directories.append(os.path.dirname(self._path))
         download_directory = QtCore.QStandardPaths.writableLocation(QtCore.QStandardPaths.DownloadLocation)
         if download_directory != "" and download_directory != os.path.dirname(self._path):
             images_directories.append(download_directory)
+
+        # registry to search for images
         self._registry = Registry(images_directories)
         self._registry.image_list_changed_signal.connect(self.images_changed_signal.emit)
 
+        # appliance object
         self._appliance = Appliance(self._registry, self._path)
+        self.setWindowTitle("Install {} appliance".format(self._appliance["name"]))
 
-        self.uiApplianceVersionTreeWidget.currentItemChanged.connect(self._applianceVersionCurrentItemChangedSlot)
-        self.uiRefreshPushButton.clicked.connect(self.images_changed_signal.emit)
-        self.uiDownloadPushButton.clicked.connect(self._downloadPushButtonClickedSlot)
-        self.uiImportPushButton.clicked.connect(self._importPushButtonClickedSlot)
-        self.uiCreateVersionPushButton.clicked.connect(self._createVersionPushButtonClickedSlot)
+        # add a custom button to show appliance information
+        if self._appliance["registry_version"] < 8:
+            # FIXME: show appliance info for v8
+            self.setButtonText(QtWidgets.QWizard.CustomButton1, "&Appliance info")
+            self.setOption(QtWidgets.QWizard.HaveCustomButton1, True)
+            self.customButtonClicked.connect(self._showApplianceInfoSlot)
 
+        # customize the server selection
         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("Install the appliance on the main server")
@@ -97,68 +130,30 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
 
         self.uiServerWizardPage.isComplete = self._uiServerWizardPage_isComplete
 
-        # symbols loaded from controller
-        self._symbols = []
-
-
     def initializePage(self, page_id):
         """
-        Initialize Wizard pages.
+        Initialize wizard pages.
 
         :param page_id: page identifier
         """
+
         super().initializePage(page_id)
 
+        # add symbol
         if self._appliance["category"] == "guest":
-            symbol = ":/symbols/computer.svg"
+            if self._appliance.template_type() == "docker":
+                symbol = ":/symbols/docker_guest.svg"
+            elif self._appliance.template_type() == "qemu":
+                symbol = ":/symbols/qemu_guest.svg"
+            else:
+                symbol = ":/symbols/computer.svg"
         else:
             symbol = ":/symbols/{}.svg".format(self._appliance["category"])
         self.page(page_id).setPixmap(QtWidgets.QWizard.LogoPixmap, QtGui.QPixmap(symbol))
 
-        if "qemu" in self._appliance:
-            type = "qemu"
-        elif "iou" in self._appliance:
-            type = "iou"
-        elif "docker" in self._appliance:
-            type = "docker"
-        elif "dynamips" in self._appliance:
-            type = "dynamips"
+        if self.page(page_id) == self.uiServerWizardPage:
 
-        if self.page(page_id) == self.uiInfoWizardPage:
             Controller.instance().getSymbols(self._getSymbolsCallback)
-
-            self.uiInfoWizardPage.setTitle(self._appliance["product_name"])
-            self.uiDescriptionLabel.setText(self._appliance["description"])
-
-            info = (
-                ("Category", "category"),
-                ("Product", "product_name"),
-                ("Vendor", "vendor_name"),
-                ("Status", "status"),
-                ("Maintainer", "maintainer"),
-                ("Architecture", "qemu/arch"),
-                ("KVM", "qemu/kvm")
-            )
-
-            self.uiInfoTreeWidget.clear()
-            for (name, key) in info:
-                if "/" in key:
-                    key, subkey = key.split("/")
-                    value = self._appliance.get(key, {}).get(subkey, None)
-                else:
-                    value = self._appliance.get(key, None)
-                if value is None:
-                    continue
-                item = QtWidgets.QTreeWidgetItem([name + ":", value])
-                font = item.font(0)
-                font.setBold(True)
-                item.setFont(0, font)
-                self.uiInfoTreeWidget.addTopLevelItem(item)
-
-        elif self.page(page_id) == self.uiServerWizardPage:
-            is_mac = ComputeManager.instance().localPlatform().startswith("darwin")
-            is_win = ComputeManager.instance().localPlatform().startswith("win")
-
             self.uiRemoteServersComboBox.clear()
             if len(ComputeManager.instance().remoteComputes()) == 0:
                 self.uiRemoteRadioButton.setEnabled(False)
@@ -167,104 +162,142 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
                 for compute in ComputeManager.instance().remoteComputes():
                     self.uiRemoteServersComboBox.addItem(compute.name(), compute)
 
-            if not ComputeManager.instance().vmCompute():
-                self.uiVMRadioButton.setEnabled(False)
+            #if ComputeManager.instance().localPlatform() is None:
+            #    self.uiLocalRadioButton.setEnabled(False)
 
-            if ComputeManager.instance().localPlatform() is None:
-                self.uiLocalRadioButton.setEnabled(False)
-            elif is_mac or is_win:
-                if type == "qemu":
-                    # Qemu has issues on OSX and Windows we disallow usage of the local server
-                    if not LocalConfig.instance().experimental():
-                        self.uiLocalRadioButton.setEnabled(False)
-                elif type != "dynamips":
-                    self.uiLocalRadioButton.setEnabled(False)
-
-            if ComputeManager.instance().vmCompute():
-                self.uiVMRadioButton.setChecked(True)
-            elif ComputeManager.instance().localCompute() and self.uiLocalRadioButton.isEnabled():
+            if ComputeManager.instance().localCompute() and self.uiLocalRadioButton.isEnabled():
                 self.uiLocalRadioButton.setChecked(True)
             elif self.uiRemoteRadioButton.isEnabled():
                 self.uiRemoteRadioButton.setChecked(True)
             else:
                 self.uiRemoteRadioButton.setChecked(False)
 
-            if is_mac or is_win:
-                if not self.uiRemoteRadioButton.isEnabled() \
-                        and not self.uiVMRadioButton.isEnabled() \
-                        and not self.uiLocalRadioButton.isEnabled():
-                    QtWidgets.QMessageBox.warning(
-                        self, "No GNS3 VM available.",
-                        "GNS3 VM is not available, please configure GNS3 VM before adding new Appliance.")
-
         elif self.page(page_id) == self.uiFilesWizardPage:
-            self._registry.getRemoteImageList(self._appliance.emulator(), self._compute_id)
+            if Controller.instance().isRemote() or self._compute_id != "local":
+                self._registry.getRemoteImageList()
+            else:
+                self.images_changed_signal.emit()
 
-        elif self.page(page_id) == self.uiQemuWizardPage:
-            Qemu.instance().getQemuBinariesFromServer(self._compute_id, qpartial(self._getQemuBinariesFromServerCallback), [self._appliance["qemu"]["arch"]])
+        elif self.page(page_id) == self.uiInstructionsPage:
 
-        elif self.page(page_id) == self.uiSummaryWizardPage:
-            self.uiSummaryTreeWidget.clear()
-
-            for key in self._appliance[type]:
-                item = QtWidgets.QTreeWidgetItem([key.replace('_', ' ').capitalize() + ":", str(self._appliance[type][key])])
-                font = item.font(0)
-                font.setBold(True)
-                item.setFont(0, font)
-                self.uiSummaryTreeWidget.addTopLevelItem(item)
-            self.uiSummaryTreeWidget.resizeColumnToContents(0)
+            installation_instructions = self._appliance.get("installation_instructions", "No installation instructions available")
+            self.uiInstructionsTextEdit.setText(installation_instructions.strip())
 
         elif self.page(page_id) == self.uiUsageWizardPage:
-            self.uiUsageTextEdit.setText("The appliance is available in the {} category. \n\n{}".format(
-                self._appliance["category"].replace("_", " "),
-                self._appliance.get("usage", ""))
-            )
+            # TODO: allow taking these info fields at the version level in v8
+            category = self._appliance["category"].replace("_", " ")
+            usage = self._appliance.get("usage", "No usage information available")
+            if self._appliance["registry_version"] >= 8:
+                default_username = self._appliance.get("default_username")
+                default_password = self._appliance.get("default_password")
+                if default_username and default_password:
+                    usage += "\n\nDefault username: {}\nDefault password: {}".format(default_username, default_password)
 
-        elif self.page(page_id) == self.uiCheckServerWizardPage:
-            self.uiCheckServerLabel.setText("Please wait while checking server capacities...")
-            if 'qemu' in self._appliance:
-                if self._appliance['qemu'].get('kvm', 'require') == 'require':
-                    self._server_check = False  # If the server as the capacities for running the appliance
-                    self.uiCheckServerLabel.setText("")
-                    Qemu.instance().getQemuCapabilitiesFromServer(self._compute_id, qpartial(self._qemuServerCapabilitiesCallback))
-                    return
-            self.uiCheckServerLabel.setText("GNS3 server requirements is OK you can continue the installation")
-            self._server_check = True
+            usage_info = """
+The template will be available in the {} category.
+            
+Usage: {}
+""".format(category, usage)
 
-    def _qemuServerCapabilitiesCallback(self, result, error=None, *args, **kwargs):
-        """
-        Check if server support KVM or not
-        """
-        if error is None and "kvm" in result and self._appliance["qemu"]["arch"] in result["kvm"]:
-            self._server_check = True
-            self.uiCheckServerLabel.setText("GNS3 server requirements is OK you can continue the installation")
-        else:
-            if error:
-                msg = result["message"]
-            else:
-                msg = "The remote server doesn't support KVM. You need a Linux server or the GNS3 VM with VMware and CPU virtualization instructions."
-            self.uiCheckServerLabel.setText(msg)
-            QtWidgets.QMessageBox.critical(self, "Qemu", msg)
-            self._server_check = False
+            self.uiUsageTextEdit.setText(usage_info.strip())
 
     def _uiServerWizardPage_isComplete(self):
-        return self.uiRemoteRadioButton.isEnabled() or self.uiVMRadioButton.isEnabled() or self.uiLocalRadioButton.isEnabled()
+        return self.uiRemoteRadioButton.isEnabled() or self.uiLocalRadioButton.isEnabled()
 
-    def _imageUploadedCallback(self, result, error=False, **kwargs):
-        self._registry.getRemoteImageList(self._appliance.emulator(), self._compute_id)
+    def _imageUploadedCallback(self, result, error=False, context=None, **kwargs):
+        if context is None:
+            context = {}
+        image_path = context.get("image_path", "unknown")
+        if error:
+            log.error("Error while uploading image '{}': {}".format(image_path, result["message"]))
+        else:
+            log.info("Image '{}' has been successfully uploaded".format(image_path))
+            self._registry.getRemoteImageList()
+
+    def _showApplianceInfoSlot(self):
+        """
+        Shows appliance information.
+        """
+
+        info = (("Product", "product_name"),
+                ("Vendor", "vendor_name"),
+                ("Availability", "availability"),
+                ("Status", "status"),
+                ("Maintainer", "maintainer"))
+
+        if "qemu" in self._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 self._appliance:
+            docker_info = (("Image", "docker/image"),
+                           ("Adapters", "docker/adapters"),
+                           ("Console type", "docker/console_type"))
+            info = info + docker_info
+
+        elif "iou" in self._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 self._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 = self._appliance.get(key, {}).get(subkey, None)
+            else:
+                value = self._appliance.get(key, None)
+            if value is None:
+                continue
+            text_info += "<span style='font-weight:bold;'>{}</span>: {}<br>".format(name, value)
+
+        msgbox = QtWidgets.QMessageBox(self)
+        msgbox.setWindowTitle("Appliance information")
+        msgbox.setStyleSheet("QLabel{min-width: 600px;}") # TODO: resize details box QTextEdit{min-height: 500px;}
+        msgbox.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding)
+        msgbox.setText(text_info)
+        msgbox.setDetailedText(self._appliance["description"])
+        msgbox.exec_()
 
     @qslot
     def _refreshVersions(self, *args):
         """
-        Refresh the list of files for different version of the appliance
+        Refresh the list of files for different versions of the appliance
         """
 
         if self._refreshing:
             return
         self._refreshing = True
 
-        self.uiFilesWizardPage.setSubTitle("The following versions are available for " + self._appliance["product_name"] + ".  Check the status of files required to install.")
-
+        self.uiFilesWizardPage.setSubTitle("Please select one version of " + self._appliance["product_name"] + " and import the required files. Files are searched in your downloads and GNS3 images directories by default")
         worker = WaitForLambdaWorker(lambda: self._refreshDialogWorker())
         progress_dialog = ProgressDialog(worker, "Add appliance", "Scanning directories for files...", None, busy=True, parent=self)
         progress_dialog.show()
@@ -274,13 +307,14 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
         """
         Called when we finish to scan the disk for new versions
         """
+
         if self._refreshing or self.currentPage() != self.uiFilesWizardPage:
             return
         self._refreshing = True
         self.uiApplianceVersionTreeWidget.clear()
 
         for version in self._appliance["versions"]:
-            top = QtWidgets.QTreeWidgetItem(self.uiApplianceVersionTreeWidget, ["{} {}".format(self._appliance["product_name"], version["name"])])
+            top = QtWidgets.QTreeWidgetItem(self.uiApplianceVersionTreeWidget, ["{} version {}".format(self._appliance["product_name"], version["name"])])
             size = 0
             status = "Ready to install"
             for image in version["images"].values():
@@ -288,19 +322,14 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
                     status = "Missing files"
 
                 size += image.get("filesize", 0)
-                image_widget = QtWidgets.QTreeWidgetItem(
-                    [
-                        "",
-                        image["filename"],
-                        human_filesize(image.get("filesize", 0)),
-                        image["status"],
-                        image["version"],
-                        image.get("md5sum", "")
-                    ])
+                image_widget = QtWidgets.QTreeWidgetItem([image["filename"],
+                                                          human_size(image.get("filesize", 0)),
+                                                          image["status"]])
                 if image["status"] == "Missing":
-                    image_widget.setForeground(3, QtGui.QBrush(QtGui.QColor("red")))
+                    image_widget.setForeground(2, QtGui.QBrush(QtGui.QColor("red")))
                 else:
-                    image_widget.setForeground(3, QtGui.QBrush(QtGui.QColor("green")))
+                    image_widget.setForeground(2, QtGui.QBrush(QtGui.QColor("green")))
+                    image_widget.setToolTip(0, f'{image["status"]} with path: {image["path"]}')
 
                 # Associated data stored are col 0: version, col 1: image
                 image_widget.setData(0, QtCore.Qt.UserRole, version)
@@ -314,26 +343,30 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
 
             expand = True
             if status == "Missing files":
-                top.setForeground(3, QtGui.QBrush(QtGui.QColor("red")))
+                top.setForeground(2, QtGui.QBrush(QtGui.QColor("red")))
             else:
                 expand = False
-                top.setForeground(3, QtGui.QBrush(QtGui.QColor("green")))
+                top.setForeground(2, QtGui.QBrush(QtGui.QColor("green")))
 
-            top.setData(2, QtCore.Qt.DisplayRole, human_filesize(size))
-            top.setData(3, QtCore.Qt.DisplayRole, status)
-            top.setData(2, QtCore.Qt.UserRole, self._appliance)
+            top.setData(1, QtCore.Qt.DisplayRole, human_size(size))
+            top.setData(2, QtCore.Qt.DisplayRole, status)
             top.setData(0, QtCore.Qt.UserRole, version)
+            top.setData(2, QtCore.Qt.UserRole, self._appliance)
             self.uiApplianceVersionTreeWidget.addTopLevelItem(top)
-            # self.uiApplianceVersionTreeWidget.setCurrentItem(top)
             if expand:
                 top.setExpanded(True)
 
         if len(self._appliance["versions"]) > 0:
-            self.uiApplianceVersionTreeWidget.resizeColumnToContents(0)
-            self.uiApplianceVersionTreeWidget.resizeColumnToContents(1)
+            for column in range(self.uiApplianceVersionTreeWidget.columnCount()):
+                self.uiApplianceVersionTreeWidget.resizeColumnToContents(column)
+
         self._refreshing = False
 
     def _getSymbolsCallback(self, result, error=False, **kwargs):
+        """
+        Callback to retrieve the appliance symbols.
+        """
+
         if error:
             log.warning("Cannot load symbols from controller")
         else:
@@ -341,7 +374,7 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
 
     def _refreshDialogWorker(self):
         """
-        Scan local directory in order to find the images on disk
+        Scan local directory in order to find images on the disk
         """
 
         # Docker do not have versions
@@ -350,11 +383,22 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
 
         for version in self._appliance["versions"]:
             for image in version["images"].values():
-                img = self._registry.search_image_file(self._appliance.emulator(), image["filename"], image.get("md5sum"), image.get("filesize"))
+                img = self._registry.search_image_file(
+                    self._appliance.template_type(),
+                    image["filename"],
+                    image.get("md5sum"),
+                    image.get("filesize"),
+                    strict_md5_check=not self.allowCustomFiles.isChecked()
+                )
                 if img:
-                    image["status"] = "Found"
+                    if img.location == "local":
+                        image["status"] = "Found locally"
+                    else:
+                        compute = ComputeManager.instance().getCompute(self._compute_id)
+                        image["status"] = "Found on {}".format(compute.name())
                     image["md5sum"] = img.md5sum
                     image["filesize"] = img.filesize
+                    image["path"] = img.path
                 else:
                     image["status"] = "Missing"
         self._refreshing = False
@@ -365,9 +409,9 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
         """
         Called when user select a different item in the list of appliance files
         """
+
         self.uiDownloadPushButton.hide()
         self.uiImportPushButton.hide()
-        self.uiExplainDownloadLabel.hide()
 
         if current is None or sip.isdeleted(current):
             return
@@ -381,9 +425,10 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
     @qslot
     def _downloadPushButtonClickedSlot(self, *args):
         """
-        Called when user want to download an appliance images.
-        He should have selected the file before.
+        Called when user wants to download an appliance image.
+        The file should be selected first.
         """
+
         if self._refreshing:
             return False
 
@@ -397,7 +442,7 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
             if "direct_download_url" in data:
                 QtGui.QDesktopServices.openUrl(QtCore.QUrl(data["direct_download_url"]))
                 if "compression" in data:
-                    QtWidgets.QMessageBox.warning(self, "Add appliance", "The file is compressed with {} you need to uncompress it before using it.".format(data["compression"]))
+                    QtWidgets.QMessageBox.warning(self, "Add appliance", "The file is compressed with '{}', it must be uncompressed first".format(data["compression"]))
             else:
                 QtWidgets.QMessageBox.warning(self, "Add appliance", "Download will redirect you where the required file can be downloaded, you may have to be registered with the vendor in order to download the file.")
                 QtGui.QDesktopServices.openUrl(QtCore.QUrl(data["download_url"]))
@@ -408,8 +453,24 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
         Allow user to create a new version of an appliance
         """
 
-        new_version, ok = QtWidgets.QInputDialog.getText(self, "Creating a new version", "Creating a new version allows to import unknown files to use with this appliance.\nPlease share your experience on the GNS3 community if this version works.\n\nVersion name:", QtWidgets.QLineEdit.Normal)
+        current = self.uiApplianceVersionTreeWidget.currentItem()
+        if current is None:
+            QtWidgets.QMessageBox.critical(self.parent(), "Base version", "Please select a base version")
+            return
+        base_version = current.data(0, QtCore.Qt.UserRole)
+
+        new_version_name, ok = QtWidgets.QInputDialog.getText(self, "Creating a new version", "Create a new version for this appliance.\nPlease share your experience on the GNS3 community if this version works.\n\nVersion name:", QtWidgets.QLineEdit.Normal, base_version.get("name"))
         if ok:
+            new_version = {"name": new_version_name}
+            new_version["images"] = {}
+
+            for disk_type in base_version["images"]:
+                base_filename = base_version["images"][disk_type]["filename"]
+                filename, ok = QtWidgets.QInputDialog.getText(self, "Image", "Disk image filename for {}".format(disk_type), QtWidgets.QLineEdit.Normal, base_filename)
+                if not ok:
+                    filename = base_filename
+                new_version["images"][disk_type] = {"filename": filename, "version": new_version_name}
+
             try:
                 self._appliance.create_new_version(new_version)
             except ApplianceError as e:
@@ -420,9 +481,10 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
     @qslot
     def _importPushButtonClickedSlot(self, *args):
         """
-        Called when user want to import an appliance images.
-        He should have selected the file before.
+        Called when user wants to import an appliance images.
+        The file should be selected first.
         """
+
         if self._refreshing:
             return False
 
@@ -435,62 +497,48 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
         if len(path) == 0:
             return
 
-        image = Image(self._appliance.emulator(), path, filename=disk["filename"])
+        image = Image(self._appliance.template_type(), path, filename=disk["filename"])
         try:
             if "md5sum" in disk and image.md5sum != disk["md5sum"]:
-                reply = QtWidgets.QMessageBox.question(self, "Add appliance",
-                                                       "This is not the correct file. The MD5 sum is {} and should be {}.\nDo you want to accept it at your own risks?".format(image.md5sum, disk["md5sum"]),
-                                                       QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No)
+                reply = QtWidgets.QMessageBox.question(
+                    self,
+                    "Add appliance",
+                    "This is not the correct file.\n\n"
+                    "MD5 checksum\n"
+                    f"actual:\t{image.md5sum}\n"
+                    f"expected:\t{disk['md5sum']}\n\n"
+                    "File size\n"
+                    f"actual:\t{image.filesize} bytes\n"
+                    f"expected:\t{disk['filesize']} bytes\n\n"
+                    "Do you want to accept it at your own risks?",
+                    QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No
+                )
                 if reply == QtWidgets.QMessageBox.No:
                     return
         except OSError as e:
             QtWidgets.QMessageBox.warning(self.parent(), "Add appliance", "Can't access to the image file {}: {}.".format(path, str(e)))
             return
 
-        image_upload_manger = ImageUploadManager(image, Controller.instance(), self._compute_id, self._imageUploadedCallback, LocalConfig.instance().directFileUpload())
+        image_upload_manger = ImageUploadManager(image, Controller.instance(), self.parent())
         image_upload_manger.upload()
 
-    def _getQemuBinariesFromServerCallback(self, result, error=False, **kwargs):
-        """
-        Callback for getQemuBinariesFromServer.
-
-        :param result: server response
-        :param error: indicates an error (boolean)
-        """
-
-        if error:
-            QtWidgets.QMessageBox.critical(self, "Qemu binaries", "{}".format(result["message"]))
+        # refresh the images list
+        if Controller.instance().isRemote() or self._compute_id != "local":
+            self._registry.getRemoteImageList()
         else:
-            self.uiQemuListComboBox.clear()
-            for qemu in result:
-                if qemu["version"]:
-                    self.uiQemuListComboBox.addItem("{path} (v{version})".format(path=qemu["path"], version=qemu["version"]), qemu["path"])
-                else:
-                    self.uiQemuListComboBox.addItem("{path}".format(path=qemu["path"]), qemu["path"])
-            if self.uiQemuListComboBox.count() == 1:
-                self.next()
-            else:
-                i = self.uiQemuListComboBox.findText(self._appliance["qemu"]["arch"], QtCore.Qt.MatchContains)
-                if i != -1:
-                    self.uiQemuListComboBox.setCurrentIndex(i)
+            self.images_changed_signal.emit()
 
     def _install(self, version):
         """
-        Install the appliance to GNS3
+        Install the appliance in GNS3
 
-        :params version: Version name
+        :params version: appliance version name
         """
 
-        try:
-            config = Config()
-        except (OSError, ValueError) as e:
-            QtWidgets.QMessageBox.critical(self.parent(), "Add appliance", str(e))
-            return False
-
         if version is None:
             appliance_configuration = self._appliance.copy()
-            if not "docker" in appliance_configuration:
-                # only Docker do not have version
+            if self._appliance.template_type() != "docker":
+                # only Docker do not have versions
                 return False
         else:
             try:
@@ -499,60 +547,56 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
                 QtWidgets.QMessageBox.critical(self.parent(), "Add appliance", str(e))
                 return False
 
-        while len(appliance_configuration["name"]) == 0 or not config.is_name_available(appliance_configuration["name"]):
-            QtWidgets.QMessageBox.warning(self.parent(), "Add appliance", "The name \"{}\" is already used by another appliance".format(appliance_configuration["name"]))
-            appliance_configuration["name"], ok = QtWidgets.QInputDialog.getText(self.parent(), "Add appliance", "New name:", QtWidgets.QLineEdit.Normal, appliance_configuration["name"])
+        template_manager = TemplateManager().instance()
+        while len(appliance_configuration["name"]) == 0 or not template_manager.is_name_available(appliance_configuration["name"]):
+            QtWidgets.QMessageBox.warning(self.parent(), "Add template", "The name \"{}\" is already used by another template".format(appliance_configuration["name"]))
+            appliance_configuration["name"], ok = QtWidgets.QInputDialog.getText(self.parent(), "Add template", "New name:", QtWidgets.QLineEdit.Normal, appliance_configuration["name"])
             if not ok:
                 return False
             appliance_configuration["name"] = appliance_configuration["name"].strip()
 
-        if "qemu" in appliance_configuration:
-            appliance_configuration["qemu"]["path"] = self.uiQemuListComboBox.currentData()
+        new_template = ApplianceToTemplate().new_template(appliance_configuration, self._compute_id, version, self._symbols, parent=self)
+        TemplateManager.instance().createTemplate(Template(new_template), callback=self._templateCreatedCallback)
+        return False
 
-        worker = WaitForLambdaWorker(
-            lambda: config.add_appliance(appliance_configuration, self._compute_id, self._symbols),
-            allowed_exceptions=[ConfigException, OSError])
+    def _templateCreatedCallback(self, result, error=False, **kwargs):
 
-        progress_dialog = ProgressDialog(worker, "Add appliance", "Install the appliance...", None, busy=True, parent=self)
-        progress_dialog.show()
-        if not progress_dialog.exec_():
+        if error is True:
+            QtWidgets.QMessageBox.critical(self.parent(), "Add template", "The template cannot be created: {}".format(result.get("message", "unknown")))
+            return
+
+        QtWidgets.QMessageBox.information(self.parent(), "Add template", "The appliance has been installed and a template named '{}' has been successfully created!".format(result["name"]))
+        self._template_created = True
+        self.done(True)
+
+    def _uploadImages(self, name, version):
+        """
+        Upload an image the compute.
+        """
+
+        try:
+            appliance_configuration = self._appliance.search_images_for_version(version)
+        except ApplianceError as e:
+            QtWidgets.QMessageBox.critical(self, "Appliance","Cannot install {} version {}: {}".format(name, version, e))
             return False
-
-        worker = WaitForLambdaWorker(lambda: config.save(), allowed_exceptions=[ConfigException, OSError])
-        progress_dialog = ProgressDialog(worker, "Add appliance", "Install the appliance...", None, busy=True, parent=self)
-        progress_dialog.show()
-        if progress_dialog.exec_():
-            QtWidgets.QMessageBox.information(self.parent(), "Add appliance", "{} installed!".format(appliance_configuration["name"]))
-            return True
-
-    def _uploadImages(self, version):
-        """
-        Upload an image to the compute
-        """
-
-        appliance_configuration = self._appliance.search_images_for_version(version)
         for image in appliance_configuration["images"]:
             if image["location"] == "local":
-                image = Image(self._appliance.emulator(), image["path"], filename=image["filename"])
-
-                image_upload_manger = ImageUploadManager(
-                    image, Controller.instance(), self._compute_id,
-                    self._applianceImageUploadedCallback, LocalConfig.instance().directFileUpload())
-                image_upload_manger.upload()
-
-                self._image_uploading_count += 1
-
-    def _applianceImageUploadedCallback(self, result, error=False, **kwargs):
-        self._image_uploading_count -= 1
+                if not Controller.instance().isRemote() and self._compute_id == "local" and image["path"].startswith(ImageManager.instance().getDirectory()):
+                    log.debug("{} is already on the local server".format(image["path"]))
+                    return True
+                image = Image(self._appliance.template_type(), image["path"], filename=image["filename"])
+                image_upload_manager = ImageUploadManager(image, Controller.instance(), self.parent())
+                if not image_upload_manager.upload():
+                    return False
+        return True
 
     def nextId(self):
         if self.currentPage() == self.uiServerWizardPage:
-            if "docker" in self._appliance:
-                return super().nextId() + 3
-            elif "qemu" not in self._appliance:
-                return super().nextId() + 1
-        elif self.currentPage() == self.uiFilesWizardPage:
-            if "qemu" not in self._appliance:
+            if self._appliance.template_type() == "docker":
+                # skip Qemu binary selection and files pages if this is a Docker appliance
+                return super().nextId() + 2
+            elif not self._appliance.get("installation_instructions"):
+                # skip the installation instructions page if there are no instructions
                 return super().nextId() + 1
         return super().nextId()
 
@@ -562,6 +606,8 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
         """
 
         if self.currentPage() == self.uiFilesWizardPage:
+            # validate the files page
+
             if self._refreshing:
                 return False
             current = self.uiApplianceVersionTreeWidget.currentItem()
@@ -580,13 +626,17 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
                                                    QtWidgets.QMessageBox.Yes, QtWidgets.QMessageBox.No)
             if reply == QtWidgets.QMessageBox.No:
                 return False
-            self._uploadImages(version["name"])
+
+            return self._uploadImages(appliance["name"], version["name"])
 
         elif self.currentPage() == self.uiUsageWizardPage:
-            if self._image_uploading_count > 0:
-                QtWidgets.QMessageBox.critical(self, "Add appliance", "Please wait for all images to be uploaded...")
-                return False
+            # validate the usage page
 
+            if self._template_created:
+                return True
+            if self._image_uploading_count > 0:
+                QtWidgets.QMessageBox.critical(self, "Add appliance", "Please wait for appliance files to be uploaded")
+                return False
             current = self.uiApplianceVersionTreeWidget.currentItem()
             if current:
                 version = current.data(0, QtCore.Qt.UserRole)
@@ -595,44 +645,24 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
                 return self._install(None)
 
         elif self.currentPage() == self.uiServerWizardPage:
+            # validate the server page
+
             if self.uiRemoteRadioButton.isChecked():
                 if len(ComputeManager.instance().remoteComputes()) == 0:
-                    QtWidgets.QMessageBox.critical(self, "Remote server", "There is no remote server registered in your preferences")
+                    QtWidgets.QMessageBox.critical(self, "Remote server", "There is no remote servers configured in your preferences")
                     return False
                 self._compute_id = self.uiRemoteServersComboBox.itemData(self.uiRemoteServersComboBox.currentIndex()).id()
-            elif hasattr(self, "uiVMRadioButton") and self.uiVMRadioButton.isChecked():
-                self._compute_id = "vm"
             else:
                 if ComputeManager.instance().localPlatform():
                     if (ComputeManager.instance().localPlatform().startswith("darwin") or ComputeManager.instance().localPlatform().startswith("win")):
                         if "qemu" in self._appliance:
-                            reply = QtWidgets.QMessageBox.question(self, "Appliance", "Qemu on Windows and MacOSX is not supported by the GNS3 team. Are you sur to continue?", QtWidgets.QMessageBox.Yes, QtWidgets.QMessageBox.No)
+                            reply = QtWidgets.QMessageBox.question(self, "Appliance", "Qemu on Windows and macOS is not supported by the GNS3 team. Do you want to continue?", QtWidgets.QMessageBox.Yes, QtWidgets.QMessageBox.No)
                             if reply == QtWidgets.QMessageBox.No:
                                 return False
-
                 self._compute_id = "local"
 
-        elif self.currentPage() == self.uiQemuWizardPage:
-            if self.uiQemuListComboBox.currentIndex() == -1:
-                QtWidgets.QMessageBox.critical(self, "Qemu binary", "No compatible Qemu binary selected")
-                return False
-
-        elif self.currentPage() == self.uiCheckServerWizardPage:
-            return self._server_check
-
         return True
 
-    @qslot
-    def _vmToggledSlot(self, checked):
-        """
-        Slot for when the VM radio button is toggled.
-
-        :param checked: either the button is checked or not
-        """
-        if checked:
-            self.uiRemoteServersGroupBox.setEnabled(False)
-            self.uiRemoteServersGroupBox.hide()
-
     @qslot
     def _remoteServerToggledSlot(self, checked):
         """
@@ -655,3 +685,21 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
         if checked:
             self.uiRemoteServersGroupBox.setEnabled(False)
             self.uiRemoteServersGroupBox.hide()
+
+    @qslot
+    def _allowCustomFilesChangedSlot(self, checked):
+        """
+        Slot for when user want to upload images which don't match md5
+
+        :param checked: if allows or doesn't allow custom files
+        :return:
+        """
+        if checked:
+            reply = QtWidgets.QMessageBox.question(self, "Custom files",
+                "This option allows files with different MD5 checksums. This feature is only for advanced users and can lead "
+                "to unexpected problems. Do you want to proceed?",
+                QtWidgets.QMessageBox.Yes, QtWidgets.QMessageBox.No)
+
+            if reply == QtWidgets.QMessageBox.No:
+                self.allowCustomFiles.setChecked(False)
+                return False

gns3/dialogs/configuration_dialog.py

@@ -49,7 +49,6 @@ class ConfigurationDialog(QtWidgets.QDialog, Ui_configurationDialog):
         self._settings = settings
         self._configuration_page = configuration_page
 
-    @property
     def settings(self):
         return self._settings
 

gns3/dialogs/console_command_dialog.py

@@ -44,6 +44,9 @@ class ConsoleCommandDialog(QtWidgets.QDialog, Ui_uiConsoleCommandDialog):
         """
         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
 
@@ -121,8 +124,8 @@ class ConsoleCommandDialog(QtWidgets.QDialog, Ui_uiConsoleCommandDialog):
         dialog = ConsoleCommandDialog(parent, console_type=console_type, current=current)
         dialog.show()
         if dialog.exec_():
-            return (True, dialog.uiCommandPlainTextEdit.toPlainText().replace("\n", " "))
-        return (False, None)
+            return True, dialog.uiCommandPlainTextEdit.toPlainText().replace("\n", " ")
+        return False, None
 
 
 if __name__ == '__main__':

gns3/dialogs/custom_adapters_configuration_dialog.py

@@ -0,0 +1,205 @@
+# -*- 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.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.ItemIsEditable)
+            item.setText(0, "Adapter {}".format(adapter_number))
+            item.setData(0, QtCore.Qt.UserRole, adapter_number)
+            item.setData(1, QtCore.Qt.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.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.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.UserRole)
+            custom_adapter_settings["adapter_number"] = adapter_number
+            original_port_name = item.data(1, QtCore.Qt.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

@@ -15,11 +15,11 @@
 # 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 psutil
 import platform
 import os
 import stat
-import sys
 import struct
 
 from gns3.qt import QtWidgets
@@ -92,19 +92,6 @@ class DoctorDialog(QtWidgets.QDialog, Ui_DoctorDialog):
             return (1, "Experimental features are enabled. Turn them off by going to Preferences -> General -> Miscellaneous.")
         return (0, None)
 
-    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
-        return (0, None)
-
     def checkFreeRam(self):
         """Checking for amount of free virtual memory"""
 
@@ -186,39 +173,9 @@ class DoctorDialog(QtWidgets.QDialog, Ui_DoctorDialog):
             pass
         return (0, None)
 
-    def _checkWindowsService(self, service_name):
-
-        import pywintypes
-        import win32service
-        import win32serviceutil
-
-        try:
-            if win32serviceutil.QueryServiceStatus(service_name, None)[1] != win32service.SERVICE_RUNNING:
-                return False
-        except pywintypes.error as e:
-            if e.winerror == 1060:
-                return False
-            else:
-                raise
-        return True
-
-    def checkRPFServiceIsRunning(self):
-        """Check if the RPF service is running (required to use Ethernet NIOs)"""
-
-        if not sys.platform.startswith("win"):
-            return (0, None)
-
-        import pywintypes
-        try:
-            if not self._checkWindowsService("npf") and not self._checkWindowsService("npcap"):
-                return (2, "The NPF or NPCAP service is not installed, please install Winpcap or Npcap and reboot")
-        except pywintypes.error as e:
-            return (2, "Could not check if the NPF or Npcap service is running: {}".format(e.strerror))
-
-        return (0, None)
 
 if __name__ == '__main__':
-    import sys
+
     app = QtWidgets.QApplication(sys.argv)
     main = QtWidgets.QMainWindow()
     dialog = DoctorDialog(main, console=True)

gns3/dialogs/edit_compute_dialog.py

@@ -34,39 +34,15 @@ class EditComputeDialog(QtWidgets.QDialog, Ui_EditComputeDialog):
 
         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())
-
-            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)
+            index = self.uiServerProtocolComboBox.findText(self._compute.protocol().upper())
+            self.uiServerProtocolComboBox.setCurrentIndex(index)
+            self.uiServerUserLineEdit.setText(self._compute.user())
 
     def compute(self):
         return self._compute
@@ -78,22 +54,22 @@ class EditComputeDialog(QtWidgets.QDialog, Ui_EditComputeDialog):
 
         host = self.uiServerHostLineEdit.text().strip()
         name = self.uiServerNameLineEdit.text().strip()
-        protocol = "http"
+        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))
+            QtWidgets.QMessageBox.critical(self, "Remote compute", "Invalid compute 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))
+            QtWidgets.QMessageBox.critical(self, "Remote compute", "Invalid compute name {}".format(name))
             return
         if port is None or port < 1:
-            QtWidgets.QMessageBox.critical(self, "Remote compute", "Invalid remote server port {}".format(port))
+            QtWidgets.QMessageBox.critical(self, "Remote compute", "Invalid compute port {}".format(port))
             return
 
         if not self._compute:
@@ -102,12 +78,8 @@ class EditComputeDialog(QtWidgets.QDialog, Ui_EditComputeDialog):
         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)
+        self._compute.setUser(user)
+        self._compute.setPassword(password)
 
         super().accept()
 

gns3/dialogs/edit_project_dialog.py

@@ -15,7 +15,9 @@
 # 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 gns3.utils import parse_version
+
+from ..qt import QtGui, QtWidgets, QtCore, qslot, qpartial
 from ..topology import Topology
 from ..ui.edit_project_dialog_ui import Ui_EditProjectDialog
 
@@ -36,7 +38,8 @@ class EditProjectDialog(QtWidgets.QDialog, Ui_EditProjectDialog):
         self.uiProjectAutoStartCheckBox.setChecked(self._project.autoStart())
         self.uiSceneWidthSpinBox.setValue(self._project.sceneWidth())
         self.uiSceneHeightSpinBox.setValue(self._project.sceneHeight())
-        self.uiGridSizeSpinBox.setValue(self._project.gridSize())
+        self.uiNodeGridSizeSpinBox.setValue(self._project.nodeGridSize())
+        self.uiDrawingGridSizeSpinBox.setValue(self._project.drawingGridSize())
 
         self.uiGlobalVariablesGrid.setAlignment(QtCore.Qt.AlignTop)
 
@@ -45,18 +48,38 @@ class EditProjectDialog(QtWidgets.QDialog, Ui_EditProjectDialog):
         self.uiNewVarButton.clicked.connect(self.onAddNewVariable)
         self.uiGlobalVariablesGrid.addWidget(self.uiNewVarButton, 0, 3, QtCore.Qt.AlignRight)
 
-        self._variables = self.setUpVariables()
+        self._readme_filename = "README.txt"
+        self.uiTabWidget.currentChanged.connect(self._previewMarkdownSlot)
+        self._loadReadme()
+        self._variables = self._project.variables()
+        if not self._variables:
+            self._variables = [{"name": "", "value": ""}]
         self.updateGlobalVariables()
 
-    def setUpVariables(self):
-        new_variable = {"name": "", "value": ""}
-        variables = self._project.variables()
+    def _loadReadme(self):
 
-        if variables is not None:
-            variables.append(new_variable)
-        else:
-            variables = [new_variable]
-        return variables
+        self._project.get("/files/{}".format(self._readme_filename), self._loadedReadme, raw=True)
+
+    def _loadedReadme(self, result, error=False, context={}, **kwargs):
+
+        if not error:
+            content = result.decode("utf-8", errors="replace")
+            self.uiReadmeTextEdit.setPlainText(content)
+
+    def _previewMarkdownSlot(self, index):
+
+        # index 1 is preview tab
+        if index == 1:
+
+            # QTextDocument before Qt version 5.14 doesn't support Markdown
+            if parse_version(QtCore.QT_VERSION_STR) < parse_version("5.14.0") or parse_version(QtCore.PYQT_VERSION_STR) < parse_version("5.14.0"):
+                QtWidgets.QMessageBox.critical(self, "Markdown preview", "Markdown preview is only support with Qt version 5.14.0 or above")
+                return
+
+            # show Markdown preview
+            document = QtGui.QTextDocument()
+            self.uiReadmePreview.setDocument(document)
+            document.setMarkdown(self.uiReadmeTextEdit.toPlainText())
 
     def updateGlobalVariables(self):
         while True:
@@ -97,7 +120,7 @@ class EditProjectDialog(QtWidgets.QDialog, Ui_EditProjectDialog):
         variable["value"] = text
 
     def _cleanVariables(self):
-        return [v for v in self._variables if v.get("name", "").strip() != ""]
+        return [v for v in self._variables if v.get("name").strip() != ""]
 
     def done(self, result):
         """
@@ -107,13 +130,27 @@ class EditProjectDialog(QtWidgets.QDialog, Ui_EditProjectDialog):
         """
 
         if result:
-            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.setGridSize(self.uiGridSizeSpinBox.value())
-            self._project.setVariables(self._cleanVariables())
-            self._project.update()
+            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()
+                content = self.uiReadmeTextEdit.toPlainText()
+                if content:
+                    self._project.post("/files/{}".format(self._readme_filename), self._saveReadmeCallback, body=content)
         super().done(result)
+
+    def _saveReadmeCallback(self, result, error=False, **kwargs):
+
+        if error:
+            QtWidgets.QMessageBox.critical(self, "Edit project", "Could not created readme file")

gns3/dialogs/file_editor_dialog.py

@@ -64,9 +64,10 @@ class FileEditorDialog(QtWidgets.QDialog, Ui_FileEditorDialog):
     def _refreshSlot(self):
         self._target.get("/files/" + self._path, self._getCallback)
 
-    def _getCallback(self, result, error=False, raw_body=None, **kwargs):
+    def _getCallback(self, result, error=False, **kwargs):
+
         if not error:
-            self.uiFileTextEdit.setText(raw_body.decode("utf-8", errors="ignore"))
+            self.uiFileTextEdit.setText(result)
         elif result.get("status") == 404:
             if self._default:
                 self.uiFileTextEdit.setText(self._default)

gns3/dialogs/idlepc_dialog.py

@@ -62,7 +62,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):
+    def _applySlot(self, update_template=False):
         """
         Applies an Idle-PC value.
         """
@@ -78,8 +78,9 @@ 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)
 
-        # apply the idle-pc to templates with the same IOS image
-        self._router.module().updateImageIdlepc(ios_image, idlepc)
+        if update_template:
+            # apply the idle-pc to templates with the same IOS image
+            self._router.module().updateImageIdlepc(ios_image, idlepc)
 
     def done(self, result):
         """
@@ -89,5 +90,5 @@ Select each value that appears in the list and click Apply, and note the CPU usa
         """
 
         if result:
-            self._applySlot()
+            self._applySlot(update_template=True)
         super().done(result)

gns3/dialogs/image_dialog.py

@@ -0,0 +1,256 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2022 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
+from gns3.http_client_error import HttpClientError, HttpClientCancelledRequestError
+from ..qt import QtCore, QtGui, QtWidgets, qslot, sip_is_deleted
+from ..ui.image_dialog_ui import Ui_ImageDialog
+from ..utils import human_size
+from ..controller import Controller
+
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class ImageDialog(QtWidgets.QDialog, Ui_ImageDialog):
+    """
+    Image management dialog.
+    """
+
+    def __init__(self, parent):
+        """
+        :param parent: parent widget.
+        """
+        super().__init__(parent)
+        self.setupUi(self)
+        self.uiUploadImagePushButton.clicked.connect(self._uploadImageSlot)
+        self.uiDeleteImagePushButton.clicked.connect(self._deleteImageSlot)
+        self.uiInstallAllPushButton.clicked.connect(self._installAllSlot)
+        self.uiPruneImagesPushButton.clicked.connect(self._pruneImagesSlot)
+        self.uiRefreshImagesPushButton.clicked.connect(Controller.instance().refreshImageList)
+        Controller.instance().image_list_updated_signal.connect(self._updateImageListSlot)
+        self._updateImageListSlot()
+        Controller.instance().refreshImageList()
+
+    @qslot
+    def _uploadImageSlot(self, *args):
+
+        files, _ = QtWidgets.QFileDialog.getOpenFileNames(
+            self,
+            "Select one or more images to upload",
+            QtCore.QStandardPaths.writableLocation(QtCore.QStandardPaths.DownloadLocation),
+            "Images (*.bin *.image *.iol *.qcow2 *.vmdk *.iso x86_64* i86bi*);;All files (*)"
+        )
+        error_msgs = ""
+        for path in files:
+            image_filename = os.path.basename(path)
+            install_appliances = self.uiInstallApplianceCheckBox.isChecked()
+            log.info("Uploading image '{}' to controller".format(image_filename))
+            try:
+                Controller.instance().post(
+                    f"/images/upload/{image_filename}",
+                    params={"install_appliances": install_appliances},
+                    body=pathlib.Path(path),
+                    context={"image_path": path},
+                    progress_text="Uploading {}".format(image_filename),
+                    timeout=None,
+                    wait=True
+                )
+            except HttpClientCancelledRequestError:
+                return
+            except HttpClientError as e:
+                error_msgs += f"{e}\n"
+
+        if error_msgs:
+            error_dialog = QtWidgets.QMessageBox(self)
+            error_dialog.setWindowModality(QtCore.Qt.ApplicationModal)
+            error_dialog.setWindowTitle("Image upload")
+            error_dialog.setText(f"Error while uploading images to the controller")
+            error_dialog.setDetailedText(error_msgs)
+            error_dialog.setIcon(QtWidgets.QMessageBox.Critical)
+            error_dialog.show()
+
+        Controller.instance().refreshImageList()
+
+    @qslot
+    def _deleteImageSlot(self, *args):
+
+        if len(self.uiImagesTreeWidget.selectedItems()) == 0:
+            QtWidgets.QMessageBox.critical(self, "Delete image", "No images selected")
+            return
+
+        reply = QtWidgets.QMessageBox.warning(
+            self,
+            "Delete image(s)",
+            "Delete the selected images?\nThis cannot be reverted.",
+            QtWidgets.QMessageBox.Yes,
+            QtWidgets.QMessageBox.No
+        )
+
+        if reply == QtWidgets.QMessageBox.No:
+            return
+
+        images_to_delete = set()
+        for image in self.uiImagesTreeWidget.selectedItems():
+            if sip_is_deleted(image):
+                continue
+            image_filename = image.data(0, QtCore.Qt.UserRole)
+            images_to_delete.add(image_filename)
+
+        error_msgs = ""
+        for image_filename in images_to_delete:
+            try:
+                Controller.instance().delete(
+                    f"/images/{image_filename}",
+                    progress_text=f"Deleting {image_filename}",
+                    timeout=None,
+                    wait=True
+                )
+            except HttpClientCancelledRequestError:
+                return
+            except HttpClientError as e:
+                error_msgs += f"{e}\n"
+
+        if error_msgs:
+            error_dialog = QtWidgets.QMessageBox(self)
+            error_dialog.setWindowModality(QtCore.Qt.ApplicationModal)
+            error_dialog.setWindowTitle("Image deletion")
+            error_dialog.setText(f"Error while deleting images on the controller")
+            error_dialog.setDetailedText(error_msgs)
+            error_dialog.setIcon(QtWidgets.QMessageBox.Critical)
+            error_dialog.show()
+
+        Controller.instance().refreshImageList()
+
+    def _installAllSlot(self, *args):
+
+        reply = QtWidgets.QMessageBox.warning(
+            self,
+            "Install appliance(s)",
+            "This will attempt to automatically create templates based on image checksums.\nContinue?",
+            QtWidgets.QMessageBox.Yes,
+            QtWidgets.QMessageBox.No
+        )
+
+        if reply == QtWidgets.QMessageBox.No:
+            return
+
+        Controller.instance().post(
+            f"/images/install",
+            progress_text=f"Installing appliances",
+            timeout=None,
+            wait=True
+        )
+
+    @qslot
+    def _pruneImagesSlot(self, *args):
+
+        reply = QtWidgets.QMessageBox.warning(
+            self,
+            "Prune image(s)",
+            "Delete all images not used by a template?\nThis cannot be reverted.",
+            QtWidgets.QMessageBox.Yes,
+            QtWidgets.QMessageBox.No
+        )
+
+        if reply == QtWidgets.QMessageBox.No:
+            return
+
+        error_msgs = ""
+        try:
+            Controller.instance().delete(
+                f"/images/prune",
+                progress_text=f"Pruning images",
+                timeout=None,
+                wait=True
+            )
+        except HttpClientCancelledRequestError:
+            return
+        except HttpClientError as e:
+            error_msgs += f"{e}\n"
+
+        if error_msgs:
+            error_dialog = QtWidgets.QMessageBox(self)
+            error_dialog.setWindowModality(QtCore.Qt.ApplicationModal)
+            error_dialog.setWindowTitle("Image pruning")
+            error_dialog.setText(f"Error while deleting images on the controller")
+            error_dialog.setDetailedText(error_msgs)
+            error_dialog.setIcon(QtWidgets.QMessageBox.Critical)
+            error_dialog.show()
+
+        Controller.instance().refreshImageList()
+
+    @qslot
+    def _updateImageListSlot(self, *args):
+
+        self.uiImagesTreeWidget.clear()
+        self.uiDeleteImagePushButton.setEnabled(False)
+        self.uiImagesTreeWidget.setUpdatesEnabled(False)
+        items = []
+        for image in Controller.instance().images():
+            item = QtWidgets.QTreeWidgetItem([image["filename"], image["image_type"], human_size(image["image_size"])])
+            item.setData(0, QtCore.Qt.UserRole, image["filename"])
+            item.setToolTip(0, f'{image["filename"]} {image["checksum"]}')
+            items.append(item)
+
+        self.uiImagesTreeWidget.addTopLevelItems(items)
+        if len(Controller.instance().images()):
+            self.uiDeleteImagePushButton.setEnabled(True)
+
+        self.uiImagesTreeWidget.header().setResizeContentsPrecision(100)  # How many rows are checked for the resize for performance reason
+        self.uiImagesTreeWidget.resizeColumnToContents(0)
+        self.uiImagesTreeWidget.resizeColumnToContents(1)
+        self.uiImagesTreeWidget.resizeColumnToContents(2)
+        self.uiImagesTreeWidget.sortItems(0, QtCore.Qt.AscendingOrder)
+        self.uiImagesTreeWidget.setUpdatesEnabled(True)
+
+    def contextMenuEvent(self, event):
+        """
+        Handles all context menu events.
+
+        :param event: QContextMenuEvent instance
+        """
+
+        items = self.uiImagesTreeWidget.selectedItems()
+        if items:
+            menu = QtWidgets.QMenu()
+            copy = QtWidgets.QAction("&Copy image information to clipboard", menu)
+            copy.triggered.connect(self._copyToClipboardSlot)
+            menu.addAction(copy)
+            menu.exec_(event.globalPos())
+
+    def _copyToClipboardSlot(self):
+        """
+        Copies the selected image tooltip to the clipboard.
+        """
+
+        items = self.uiImagesTreeWidget.selectedItems()
+        if items:
+            QtWidgets.QApplication.clipboard().setText(items[0].toolTip(0))
+            log.info(f"'{items[0].toolTip(0)}' copied to clipboard")
+
+    def keyPressEvent(self, e):
+        """
+        Event handler in order to properly handle escape.
+        """
+
+        if e.key() == QtCore.Qt.Key_Escape:
+            self.close()
+        elif e.matches(QtGui.QKeySequence.Copy):
+            self._copyToClipboardSlot()

gns3/dialogs/login_dialog.py

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2021 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
+from ..ui.login_dialog_ui import Ui_LoginDialog
+
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class LoginDialog(QtWidgets.QDialog, Ui_LoginDialog):
+
+    """
+    Login dialog.
+    """
+
+    def __init__(self, parent):
+        """
+        :param parent: parent widget.
+        """
+
+        super().__init__(parent)
+        self.setupUi(self)
+        self._parent = parent
+        self._username = None
+        self._password = None
+
+    def getUsername(self):
+
+        return self._username
+
+    def setUsername(self, username):
+
+        self.uiUsernameLineEdit.setText(username)
+
+    def getPassword(self):
+
+        return self._password
+
+    def done(self, result):
+
+        if result:
+            self._username = self.uiUsernameLineEdit.text()
+            self._password = self.uiPasswordLineEdit.text()
+        super().done(result)

gns3/dialogs/new_appliance_dialog.py

@@ -1,121 +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, 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)
-        elif self.uiAddVPCSRadioButton.isChecked():
-            self._setPreferencesPane(dialog, "VPCS").uiNewVPCSPushButton.clicked.emit(False)
-        elif self.uiAddCloudRadioButton.isChecked():
-            self._setPreferencesPane(dialog, "Cloud nodes").uiNewCloudNodePushButton.clicked.emit(False)
-        elif self.uiAddEthernetHubRadioButton.isChecked():
-            self._setPreferencesPane(dialog, "Ethernet hubs").uiNewEthernetHubPushButton.clicked.emit(False)
-        elif self.uiAddEthernetSwitchRadioButton.isChecked():
-            self._setPreferencesPane(dialog, "Ethernet switches").uiNewEthernetSwitchPushButton.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
-        """
-
-        panes = dialog.uiTreeWidget.findItems(name, QtCore.Qt.MatchFixedString)
-        if len(panes) > 0:
-            child_pane = panes[0].child(0)
-            dialog.uiTreeWidget.setCurrentItem(child_pane)
-        else:
-            i = 0
-            root = dialog.uiTreeWidget.invisibleRootItem()
-            while i < root.childCount():
-                root_item = root.child(i)
-                x = 0
-                while x < root_item.childCount():
-                    item = root_item.child(x)
-                    x += 1
-                    if item.text(0) == name:
-                        dialog.uiTreeWidget.setCurrentItem(item)
-                i += 1
-        dialog.addModifiedPage(dialog.uiStackedWidget.currentWidget())
-        return dialog.uiStackedWidget.currentWidget()
-
-
-if __name__ == '__main__':
-    import sys
-    app = QtWidgets.QApplication(sys.argv)
-    main = QtWidgets.QMainWindow()
-    dialog = NewApplianceDialog(main)
-    dialog._setPreferencesPane(PreferencesDialog(main), "Ethernet hubs").uiNewEthernetHubPushButton.clicked.emit(False)
-    dialog.show()
-    exit_code = app.exec_()

gns3/dialogs/new_template_wizard.py

@@ -0,0 +1,288 @@
+# -*- 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 sip
+import os
+
+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.ModernStyle)
+        if sys.platform.startswith("darwin"):
+            # we want to see the cancel button on OSX
+            self.setOptions(QtWidgets.QWizard.NoDefaultButton)
+
+        # add a custom button to show appliance information
+        self.setButtonText(QtWidgets.QWizard.CustomButton1, "&Update from online registry")
+        self.setOption(QtWidgets.QWizard.HaveCustomButton1, True)
+        self.customButtonClicked.connect(self._downloadAppliancesSlot)
+        self.button(QtWidgets.QWizard.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.ItemIsSelectable)
+        parent_switches = QtWidgets.QTreeWidgetItem(self.uiAppliancesTreeWidget)
+        parent_switches.setText(0, "Switches")
+        parent_switches.setFlags(parent_switches.flags() & ~QtCore.Qt.ItemIsSelectable)
+        parent_guests = QtWidgets.QTreeWidgetItem(self.uiAppliancesTreeWidget)
+        parent_guests.setText(0, "Guests")
+        parent_guests.setFlags(parent_guests.flags() & ~QtCore.Qt.ItemIsSelectable)
+        parent_firewalls = QtWidgets.QTreeWidgetItem(self.uiAppliancesTreeWidget)
+        parent_firewalls.setText(0, "Firewalls")
+        parent_firewalls.setFlags(parent_firewalls.flags() & ~QtCore.Qt.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.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.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.CustomButton1).show()
+            self.setButtonText(QtWidgets.QWizard.FinishButton, "&Install")
+            self._get_appliances_from_server()
+        else:
+            self.button(QtWidgets.QWizard.CustomButton1).hide()
+
+    def cleanupPage(self, page_id):
+        """
+        Restore button default settings on the first page.
+        """
+
+        self.button(QtWidgets.QWizard.CustomButton1).hide()
+        self.setButtonText(QtWidgets.QWizard.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.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

@@ -0,0 +1,56 @@
+# -*- 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/password_dialog.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2025 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 ..qt import QtCore, QtGui, QtWidgets
+from ..ui.password_dialog_ui import Ui_PasswordDialog
+
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class PasswordDialog(QtWidgets.QDialog, Ui_PasswordDialog):
+
+    """
+    Password dialog.
+    """
+
+    def __init__(self, parent):
+        """
+        :param parent: parent widget.
+        """
+
+        super().__init__(parent)
+        self.setupUi(self)
+        self._password = None
+
+        self._eye_on_icon = QtGui.QIcon(':/icons/eye-on.svg')
+        self._eye_off_icon = QtGui.QIcon(':/icons/eye-off.svg')
+        for line_edit in [self.uiPasswordLineEdit, self.uiConfirmPasswordLineEdit]:
+            action = line_edit.addAction(self._eye_on_icon, QtWidgets.QLineEdit.TrailingPosition)
+            button = action.associatedWidgets()[-1]
+            button.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
+            button.pressed.connect(self.onPressedSlot)
+            #button.released.connect(self.onReleasedSlot)
+
+    def onPressedSlot(self):
+
+        button = self.sender()
+        line_edit = button.parent()
+        if line_edit.echoMode() == QtWidgets.QLineEdit.Password:
+            button.setIcon(self._eye_off_icon)
+            line_edit.setEchoMode(QtWidgets.QLineEdit.Normal)
+        else:
+            button.setIcon(self._eye_on_icon)
+            line_edit.setEchoMode(QtWidgets.QLineEdit.Password)
+
+    # def onReleasedSlot(self):
+    #
+    #     button = self.sender()
+    #     button.setIcon(self._eye_on_icon)
+    #     button.parent().setEchoMode(QtWidgets.QLineEdit.Password)
+
+    def getPassword(self):
+
+        return self._password
+
+    def done(self, result):
+
+        if result:
+            new_password = self.uiPasswordLineEdit.text()
+            confirm_password = self.uiConfirmPasswordLineEdit.text()
+            if new_password != confirm_password:
+                QtWidgets.QMessageBox.critical(self, "Error", "Passwords do not match.")
+                return
+            pattern = re.compile(r'^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,}$')
+            if not pattern.match(new_password):
+                QtWidgets.QMessageBox.critical(self, "Error", "Password must be at least 8 characters long and contain at least one digit, one lowercase letter and one uppercase letter.")
+                return
+            self._password = new_password
+        super().done(result)

gns3/dialogs/preferences_dialog.py

@@ -21,9 +21,10 @@ Dialog to load module and built-in preference pages.
 
 from ..qt import QtCore, QtWidgets
 from ..ui.preferences_dialog_ui import Ui_PreferencesDialog
-from ..pages.server_preferences_page import ServerPreferencesPage
+from ..pages.controller_preferences_page import ControllerPreferencesPage
 from ..pages.general_preferences_page import GeneralPreferencesPage
 from ..pages.packet_capture_preferences_page import PacketCapturePreferencesPage
+from ..pages.user_preferences_page import UserPreferencesPage
 from ..pages.gns3_vm_preferences_page import GNS3VMPreferencesPage
 from ..modules import MODULES
 
@@ -84,9 +85,10 @@ class PreferencesDialog(QtWidgets.QDialog, Ui_PreferencesDialog):
         # load built-in preference pages
         pages = [
             GeneralPreferencesPage,
-            ServerPreferencesPage,
-            GNS3VMPreferencesPage,
-            PacketCapturePreferencesPage,
+            ControllerPreferencesPage,
+            UserPreferencesPage,
+            #GNS3VMPreferencesPage,
+            PacketCapturePreferencesPage
         ]
 
         for page in pages:
@@ -131,6 +133,7 @@ class PreferencesDialog(QtWidgets.QDialog, Ui_PreferencesDialog):
             QtWidgets.QLineEdit: "textChanged",
             QtWidgets.QPlainTextEdit: "textChanged",
             # QtWidgets.QTreeWidget: "itemChanged",
+            QtWidgets.QTreeWidget: "itemDoubleClicked",
             QtWidgets.QComboBox: "currentIndexChanged",
             QtWidgets.QSpinBox: "valueChanged",
             QtWidgets.QAbstractButton: "pressed"
@@ -184,10 +187,17 @@ 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())
-        self.uiStackedWidget.resize(widget.size())
+        #self.uiStackedWidget.setMinimumSize(widget.size())  # FIXME: this seems to not work on Windows and OSX
+        #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.Expanding, QtWidgets.QSizePolicy.Expanding)
+            else:
+                page.setSizePolicy(QtWidgets.QSizePolicy.Ignored, QtWidgets.QSizePolicy.Ignored)
+
     def _applyPreferences(self):
         """
         Saves all the preferences.
@@ -226,11 +236,5 @@ 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

@@ -22,6 +22,7 @@ import shutil
 from gns3.qt import QtWidgets
 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__)
@@ -39,8 +40,8 @@ class ProfileSelectDialog(QtWidgets.QDialog, Ui_ProfileSelectDialog):
             self._main.hide()
             parent = self._main
         super().__init__(parent)
-        self.setupUi(self)
 
+        self.setupUi(self)
         self.uiNewPushButton.clicked.connect(self._newPushButtonSlot)
         self.uiDeletePushButton.clicked.connect(self._deletePushButtonSlot)
 
@@ -48,12 +49,13 @@ class ProfileSelectDialog(QtWidgets.QDialog, Ui_ProfileSelectDialog):
         screen = QtWidgets.QApplication.desktop().screenGeometry()
         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")
+            path = os.path.join(appdata, "GNS3", version)
         else:
             home = os.path.expanduser("~")
-            path = os.path.join(home, ".config", "GNS3")
+            path = os.path.join(home, ".config", "GNS3", version)
         self.profiles_path = os.path.join(path, "profiles")
 
         self.uiShowAtStartupCheckBox.setChecked(LocalConfig.instance().multiProfiles())
@@ -65,9 +67,9 @@ class ProfileSelectDialog(QtWidgets.QDialog, Ui_ProfileSelectDialog):
 
         try:
             if os.path.exists(self.profiles_path):
-                for profil in sorted(os.listdir(self.profiles_path)):
-                    if not profil.startswith("."):
-                        self.uiProfileSelectComboBox.addItem(profil)
+                for profile in sorted(os.listdir(self.profiles_path)):
+                    if not profile.startswith("."):
+                        self.uiProfileSelectComboBox.addItem(profile)
         except OSError:
             pass
 
@@ -79,7 +81,7 @@ class ProfileSelectDialog(QtWidgets.QDialog, Ui_ProfileSelectDialog):
         super().accept()
 
     def _newPushButtonSlot(self):
-        profile, ok = QtWidgets.QInputDialog.getText(self.parent(), "New profile", "Profile name:")
+        profile, ok = QtWidgets.QInputDialog.getText(self, "New profile", "Profile name:")
         if ok:
             self.uiProfileSelectComboBox.addItem(profile)
             self.uiProfileSelectComboBox.setCurrentText(profile)
@@ -88,13 +90,13 @@ class ProfileSelectDialog(QtWidgets.QDialog, Ui_ProfileSelectDialog):
     def _deletePushButtonSlot(self):
         profile = self.uiProfileSelectComboBox.currentText()
         if profile == "default":
-            QtWidgets.QMessageBox.critical(self.parentWidget(), "Delete profile", "You can't delete the default profile")
+            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.parentWidget(), "Delete profile", str(e))
+                QtWidgets.QMessageBox.critical(self, "Cannot delete profile", str(e))
 
 
 if __name__ == '__main__':

gns3/dialogs/project_dialog.py

@@ -53,7 +53,7 @@ class ProjectDialog(QtWidgets.QDialog, Ui_ProjectDialog):
 
         if show_open_options:
             self.uiOpenProjectPushButton.clicked.connect(self._openProjectActionSlot)
-            self.uiRecentProjectsPushButton.clicked.connect(self._showRecentProjectsSlot)
+            self._addRecentFilesMenu()
         else:
             self.uiOpenProjectGroupBox.hide()
             self.uiProjectTabWidget.removeTab(1)
@@ -135,19 +135,28 @@ class ProjectDialog(QtWidgets.QDialog, Ui_ProjectDialog):
                                                          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},
-                                               progressText="Duplicating project '{}'...".format(name),
-                                               timeout=None)
+                    Controller.instance().post(
+                        "/projects/{project_id}/duplicate".format(project_id=project_id),
+                        self._duplicateCallback,
+                        body={"name": name, "reset_mac_addresses": reset_mac_addresses},
+                        progress_text="Duplicating project '{}'...".format(name),
+                        timeout=None,
+                        wait=True
+                    )
                 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},
-                                               progressText="Duplicating project '{}'...".format(name),
-                                               timeout=None)
+                    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},
+                        progress_text="Duplicating project '{}'...".format(name),
+                        timeout=None,
+                        wait=True
+                    )
 
     def _duplicateCallback(self, result, error=False, **kwargs):
         if error:
@@ -228,20 +237,20 @@ class ProjectDialog(QtWidgets.QDialog, Ui_ProjectDialog):
         self._main_window.openProjectActionSlot()
         self.reject()
 
-    def _showRecentProjectsSlot(self):
+    def _addRecentFilesMenu(self):
         """
-        lot to show all the recent projects in a menu.
+        Add recent projects in a menu.
         """
 
-        menu = QtWidgets.QMenu()
-        menu.triggered.connect(self._menuTriggeredSlot)
+        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.exec_(QtGui.QCursor.pos())
+        menu.triggered.connect(self._menuTriggeredSlot)
+        self.uiRecentProjectsPushButton.setMenu(menu)
 
     def _overwriteProjectCallback(self, result, error=False, **kwargs):
         if error:
@@ -275,17 +284,17 @@ class ProjectDialog(QtWidgets.QDialog, Ui_ProjectDialog):
 
         for existing_project in Controller.instance().projects():
             if self._project_settings["project_name"] == existing_project["name"] \
-               or ("project_files_dir" in self._project_settings and self._project_settings["project_files_dir"] == existing_project["path"]):
+               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 open you can not overwrite it".format(self._project_settings["project_name"]))
+                                                   '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, overwrite it?".format(existing_project["name"]),
+                                                      'Project "{}" already exists in location "{}", overwrite it?'.format(existing_project["name"], existing_project["path"]),
                                                       QtWidgets.QMessageBox.Yes,
                                                       QtWidgets.QMessageBox.No)
 

gns3/dialogs/project_export_wizard.py

@@ -0,0 +1,242 @@
+# -*- 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 datetime
+
+from gns3.qt import QtCore, QtWidgets, QtGui
+from gns3.utils import parse_version
+from gns3.http_client_error import HttpClientError, HttpClientCancelledRequestError
+from gns3.local_server import LocalServer
+from gns3.ui.export_project_wizard_ui import Ui_ExportProjectWizard
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class ExportProjectWizard(QtWidgets.QWizard, Ui_ExportProjectWizard):
+    """
+    Export project wizard.
+    """
+
+    readme_signal = QtCore.pyqtSignal()
+
+    def __init__(self, project, parent):
+
+        super().__init__(parent)
+        self.setupUi(self)
+
+        self._project = project
+        self._path = None
+        self.setWizardStyle(QtWidgets.QWizard.ModernStyle)
+        if sys.platform.startswith("darwin"):
+            # we want to see the cancel button on OSX
+            self.setOptions(QtWidgets.QWizard.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")
+        self.uiCompressionComboBox.addItem("Zstandard compression", "zstd")
+        self.uiCompressionComboBox.currentIndexChanged.connect(self._compressionChangedSlot)
+
+        # set zstd compression by default
+        self.uiCompressionComboBox.setCurrentIndex(4)
+        self.helpRequested.connect(self._showHelpSlot)
+        self.uiPathBrowserToolButton.clicked.connect(self._pathBrowserSlot)
+
+        # QTextDocument before Qt version 5.14 doesn't support Markdown
+        if parse_version(QtCore.QT_VERSION_STR) < parse_version("5.14.0") or parse_version(QtCore.PYQT_VERSION_STR) < parse_version("5.14.0"):
+            self._use_markdown = False
+        else:
+            self._use_markdown = True
+
+        self._readme_filename = "README.txt"
+        self.uiTabWidget.currentChanged.connect(self._previewMarkdownSlot)
+        self._loadReadme()
+
+    def _loadReadme(self):
+
+        self._project.get("/files/{}".format(self._readme_filename), self._loadedReadme, raw=True)
+
+    def _loadedReadme(self, result, error=False, context={}, **kwargs):
+
+        if not error:
+            content = result.decode("utf-8", errors="replace")
+            self.uiReadmeTextEdit.setPlainText(content)
+        else:
+            if self._use_markdown:
+                readme_markdown = "# Project {}\n\nCreated on: {}\n\nAuthor: John Doe <john.doe@example.com>\n\n## Description\n\nNo project description was given".format(self._project.name(), datetime.date.today())
+                self.uiReadmeTextEdit.setPlainText(readme_markdown)
+            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.DocumentsLocation)
+        if len(directory) == 0:
+            directory = LocalServer.instance().localServerSettings()["projects_path"]
+
+        path, _ = QtWidgets.QFileDialog.getSaveFileName(self, "Export project", directory,
+                                                        "GNS3 Project (*.gns3project *.gns3p)",
+                                                        "GNS3 Project (*.gns3project *.gns3p)")
+        if path is None or len(path) == 0:
+            return
+
+        self.uiPathLineEdit.setText(path)
+
+    def _previewMarkdownSlot(self, index):
+
+        # index 1 is preview tab
+        if index == 1:
+
+            if self._use_markdown is False:
+                QtWidgets.QMessageBox.critical(self, "Markdown preview", "Markdown preview is only support with Qt version 5.14.0 or above")
+                return
+
+            # show Markdown preview
+            document = QtGui.QTextDocument()
+            self.uiReadmePreviewEdit.setDocument(document)
+            document.setMarkdown(self.uiReadmeTextEdit.toPlainText())
+
+    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
+        return True
+
+    def _saveReadmeCallback(self, result, error=False, **kwargs):
+        if error:
+            QtWidgets.QMessageBox.critical(self, "Export project", "Could not created readme file")
+        self.readme_signal.emit()
+
+    def waitForReadme(self, signal, timeout=10000):
+
+        # inspired from https://www.jdreaver.com/posts/2014-07-03-waiting-for-signals-pyside-pyqt.html
+        loop = QtCore.QEventLoop()
+        signal.connect(loop.quit)
+        if timeout is not None:
+            QtCore.QTimer.singleShot(timeout, loop.quit)
+        loop.exec_()
+
+    def _compressionChangedSlot(self, index):
+        """
+        Set the default compression level.
+        """
+
+        compression = self.uiCompressionComboBox.itemData(index)
+        self.uiCompressionLevelSpinBox.setEnabled(True)
+        if compression == "zip":
+            self.uiCompressionLevelSpinBox.setValue(6)  # ZIP default compression level is 6
+        elif compression == "bzip2":
+            self.uiCompressionLevelSpinBox.setValue(9)  # BZIP2 default compression level is 9
+        elif compression == "zstd":
+            self.uiCompressionLevelSpinBox.setValue(3)  # ZSTD default compression level is 3
+        else:
+            # compression level is not supported
+            self.uiCompressionLevelSpinBox.setValue(0)
+            self.uiCompressionLevelSpinBox.setEnabled(False)
+
+    def done(self, result):
+        """
+        This dialog is closed.
+        """
+
+        if result:
+
+            content = self.uiReadmeTextEdit.toPlainText()
+            if content:
+                self._project.post("/files/{}".format(self._readme_filename), self._saveReadmeCallback, body=content)
+
+            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()
+            self.waitForReadme(self.readme_signal)
+
+            params = {
+                "include_images": include_images,
+                "include_snapshots": include_snapshots,
+                "reset_mac_addresses": reset_mac_addresses,
+                "keep_compute_ids": keep_compute_ids,
+                "compression": compression
+            }
+
+            try:
+                self._project.get(
+                    "/export",
+                    callback=None,
+                    download_progress_callback=self._downloadFileProgress,
+                    progress_text="Exporting project files...",
+                    params=params,
+                    timeout=None,
+                    wait=True,
+                    raw=True
+                )
+            except HttpClientCancelledRequestError:
+                pass
+            except HttpClientError as e:
+                QtWidgets.QMessageBox.critical(
+                    self,
+                    "Project export",
+                    f"Could not export project: {e}"
+                )
+
+        super().done(result)
+
+    def _downloadFileProgress(self, content, **kwargs):
+        """
+        Called for each part of the file
+        """
+
+        try:
+            with open(self._path, 'ab') as f:
+                f.write(content)
+        except OSError as e:
+            log.error(f"Could not write project file: {e}")
+            return

gns3/dialogs/project_welcome_dialog.py

@@ -37,9 +37,7 @@ class ProjectWelcomeDialog(QtWidgets.QDialog, Ui_ProjectWelcomeDialog):
         self.uiOkButton.clicked.connect(self._okButtonClickedSlot)
         self.gridLayout.setAlignment(QtCore.Qt.AlignTop)
         self.label.setOpenExternalLinks(True)
-
         self._variables = self._getVariables(project)
-
         self._loadReadme()
         self._addMisingVariablesEdits()
 
@@ -50,10 +48,11 @@ class ProjectWelcomeDialog(QtWidgets.QDialog, Ui_ProjectWelcomeDialog):
         return variables
 
     def _addMisingVariablesEdits(self):
-        missing = [v for v in self._variables if v.get("value", "").strip() == ""]
+        #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", ""))
+            nameLabel.setText(variable.get("name") + ":")
             self.gridLayout.addWidget(nameLabel, i, 0)
 
             valueEdit = QtWidgets.QLineEdit()
@@ -62,23 +61,23 @@ class ProjectWelcomeDialog(QtWidgets.QDialog, Ui_ProjectWelcomeDialog):
             self.gridLayout.addWidget(valueEdit, i, 1)
 
     def _loadReadme(self):
-        self._project.get("/files/README.txt", self._loadedReadme)
+        self._project.get("/files/README.txt", self._loadedReadme, raw=True)
 
-    def _loadedReadme(self, result, error=False, raw_body=None, context={}, **kwargs):
+    def _loadedReadme(self, result, error=False, context={}, **kwargs):
         if not error:
-            self.label.setText(raw_body.decode("utf-8"))
+            self.label.setText(result.decode("utf-8"))
 
     def onValueChange(self, variable, text):
         variable["value"] = text
 
     def _okButtonClickedSlot(self):
-        missing = [v for v in self._variables if v.get("value", "").strip() == ""]
+        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.Yes,
-                QtWidgets.QMessageBox.No)
+            reply = QtWidgets.QMessageBox.warning(self,
+                                                  "Missing values",
+                                                  "Are you sure you want to continue without providing missing values?",
+                                                  QtWidgets.QMessageBox.Yes,
+                                                  QtWidgets.QMessageBox.No)
             if reply == QtWidgets.QMessageBox.No:
                 return
 

gns3/dialogs/setup_wizard.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2014 GNS3 Technologies Inc.
+# Copyright (C) 2021 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
@@ -19,15 +19,12 @@ import sys
 import os
 import shutil
 
-from gns3.qt import QtCore, QtWidgets, QtGui, QtNetwork, qslot
+from gns3.qt import QtCore, QtWidgets, QtNetwork
 from gns3.controller import Controller
 from gns3.local_server import LocalServer
-from gns3.utils.progress_dialog import ProgressDialog
-from gns3.utils.wait_for_connection_worker import WaitForConnectionWorker
 
-from ..settings import DEFAULT_LOCAL_SERVER_HOST
+from ..settings import DEFAULT_CONTROLLER_HOST
 from ..ui.setup_wizard_ui import Ui_SetupWizard
-from ..version import __version__
 
 
 import logging
@@ -44,16 +41,7 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
 
         super().__init__(parent)
         self.setupUi(self)
-
-        self._gns3_vm_settings = {
-            "enable": True,
-            "headless": False,
-            "when_exit": "stop",
-            "engine": "vmware",
-            "vcpus": 1,
-            "ram": 2048,
-            "vmname": "GNS3 VM"
-        }
+        self.adjustSize()
 
         self.setWizardStyle(QtWidgets.QWizard.ModernStyle)
         if sys.platform.startswith("darwin"):
@@ -61,43 +49,32 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
             self.setOptions(QtWidgets.QWizard.NoDefaultButton)
 
         self.uiLocalServerToolButton.clicked.connect(self._localServerBrowserSlot)
-
-        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"])
 
-        # by default all radio buttons are unchecked
-        self.uiVmwareRadioButton.setAutoExclusive(False)
-        self.uiVirtualBoxRadioButton.setAutoExclusive(False)
-        self.uiVmwareRadioButton.setChecked(False)
-        self.uiVirtualBoxRadioButton.setChecked(False)
-
         # Mandatory fields
-        self.uiLocalServerWizardPage.registerField("path*", self.uiLocalServerPathLineEdit)
+        self.uiLocalControllerWizardPage.registerField("path*", self.uiLocalServerPathLineEdit)
 
         # load all available addresses
         for address in QtNetwork.QNetworkInterface.allAddresses():
-            address_string = address.toString()
-            if address.protocol() != QtNetwork.QAbstractSocket.IPv6Protocol:
-                self.uiLocalServerHostComboBox.addItem(address_string, address.toString())
+            if address.protocol() in [QtNetwork.QAbstractSocket.IPv4Protocol, QtNetwork.QAbstractSocket.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)
 
-        if sys.platform.startswith("darwin"):
-            self.uiVMwareBannerButton.setIcon(QtGui.QIcon(":/images/vmware_fusion_banner.png"))
-        else:
-            self.uiVMwareBannerButton.setIcon(QtGui.QIcon(":/images/vmware_workstation_banner.png"))
+        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.uiVMRadioButton.setText("Run the topologies in an isolated and standard VM")
-            self.uiLocalRadioButton.setText("Run the topologies on my computer")
-            self.uiLocalRadioButton.setChecked(True)
-            self.uiLocalLabel.setVisible(False)
-
-        Controller.instance().connected_signal.connect(self._refreshLocalServerStatusSlot)
-        Controller.instance().connection_failed_signal.connect(self._refreshLocalServerStatusSlot)
+            # only support local controller on Linux
+            self.uiLocalControllerRadioButton.setChecked(True)
+        else:
+            self.uiLocalControllerRadioButton.setEnabled(False)
+            self.uiRemoteControllerRadioButton.setChecked(True)
 
     def _localServerBrowserSlot(self):
         """
@@ -106,7 +83,7 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
 
         filter = ""
         if sys.platform.startswith("win"):
-            filter = "Executable (*.exe);;All files (*.*)"
+            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:
@@ -114,44 +91,6 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
 
         self.uiLocalServerPathLineEdit.setText(path)
 
-    def _VMwareBannerButtonClickedSlot(self):
-        if sys.platform.startswith("darwin"):
-            url = "http://send.onenetworkdirect.net/z/621395/CD225091/"
-        else:
-            url = "http://send.onenetworkdirect.net/z/616207/CD225091/"
-        QtGui.QDesktopServices.openUrl(QtCore.QUrl(url))
-
-    def _listVMwareVMsSlot(self):
-        """
-        Slot to refresh the VMware VMs list.
-        """
-
-        download_url = "https://github.com/GNS3/gns3-gui/releases/download/v{version}/GNS3.VM.VMware.Workstation.{version}.zip".format(version=__version__)
-        self.uiGNS3VMDownloadLinkUrlLabel.setText('The GNS3 VM can <a href="{download_url}">downloaded here</a>.<br>Import the VM in your virtualization software and hit refresh.'.format(download_url=download_url))
-        self.uiVirtualBoxRadioButton.setChecked(False)
-        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://www.vmware.com/support/developer/vix-api/. After installation you need to restart GNS3.")
-            return
-        self._refreshVMListSlot()
-
-    def _listVirtualBoxVMsSlot(self):
-        """
-        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)
-        from gns3.modules import VirtualBox
-        settings = VirtualBox.instance().settings()
-        if not os.path.exists(settings["vboxmanage_path"]):
-            QtWidgets.QMessageBox.critical(self, "VirtualBox", "VBoxManage could not be found, VirtualBox is probably not installed. After installation you need to restart GNS3.")
-            return
-        self._refreshVMListSlot()
-
     def _setPreferencesPane(self, dialog, name):
         """
         Finds the first child of the QTreeWidgetItem name.
@@ -167,13 +106,6 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
         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.
@@ -182,83 +114,46 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
         """
 
         super().initializePage(page_id)
-        if self.page(page_id) == self.uiServerWizardPage:
+        if self.page(page_id) == self.uiControllerWizardPage:
             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:
+        elif self.page(page_id) == self.uiLocalControllerWizardPage:
             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:
+                index = self.uiLocalServerHostComboBox.findText(DEFAULT_CONTROLLER_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.uiRemoteMainServerHostLineEdit.setText(DEFAULT_CONTROLLER_HOST)
                 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.uiRemoteMainServerUserLineEdit.setText(local_server_settings["username"])
                 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():
+            if self.uiLocalControllerRadioButton.isChecked():
                 local_server_settings = LocalServer.instance().localServerSettings()
-                self._addSummaryEntry("Server type:", "Local")
+                self._addSummaryEntry("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("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
-        """
-        if Controller.instance().connected():
-            self.uiLocalServerStatusLabel.setText("Connection to local server successful")
-            Controller.instance().get("/gns3vm", self._getSettingsCallback)
-        elif Controller.instance().connecting():
-            self.uiLocalServerStatusLabel.setText("Please wait connection to the GNS3 server")
-        else:
-            local_server_settings = LocalServer.instance().localServerSettings()
-            self.uiLocalServerStatusLabel.setText("Connection to local server failed.\n* Make sure GNS3 is allowed in your firewall.\n* Go back and try to change the server port\n* Please 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 if the above does not work.".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)
+                self._addSummaryEntry("User:", local_server_settings["username"])
 
     def _saveSettingsCallback(self, result, error=False, **kwargs):
         if error:
@@ -280,111 +175,45 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
         """
 
         Controller.instance().setDisplayError(True)
-        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
+        if self.currentPage() == self.uiLocalControllerWizardPage:
 
-                if self.uiVmwareRadioButton.isChecked():
-                    vm_settings["engine"] = "vmware"
-                elif self.uiVirtualBoxRadioButton.isChecked():
-                    vm_settings["engine"] = "virtualbox"
+            local_controller_settings = LocalServer.instance().localServerSettings()
+            local_controller_settings["auto_start"] = True
+            local_controller_settings["remote"] = False
+            local_controller_settings["path"] = self.uiLocalServerPathLineEdit.text().strip()
+            local_controller_settings["host"] = self.uiLocalServerHostComboBox.itemData(self.uiLocalServerHostComboBox.currentIndex())
+            local_controller_settings["port"] = self.uiLocalServerPortSpinBox.value()
 
-                # 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
-
-                self._setGNS3VMSettings(vm_settings)
-            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.")
+            if not os.path.isfile(local_controller_settings["path"]):
+                QtWidgets.QMessageBox.critical(self, "Local server", "Could not find local server {}".format(local_controller_settings["path"]))
                 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()
-
-            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"]))
+            if not os.access(local_controller_settings["path"], os.X_OK):
+                QtWidgets.QMessageBox.critical(self, "Local server", "{} is not an executable".format(local_controller_settings["path"]))
                 return False
 
-            LocalServer.instance().updateLocalServerSettings(local_server_settings)
-            LocalServer.instance().localServerAutoStartIfRequire()
+            LocalServer.instance().updateLocalServerSettings(local_controller_settings)
+
+            # start and connect to the controller if required
+            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():
-                # deactivate the GNS3 VM if using the local server
-                vm_settings = self._GNS3VMSettings()
-                vm_settings["enable"] = False
-                self._setGNS3VMSettings(vm_settings)
-
-        elif self.currentPage() == self.uiLocalServerStatusWizardPage:
-            if not Controller.instance().connected():
-                return False
+            remote_controller_settings = Controller.instance().settings()
+            remote_controller_settings["auto_start"] = False
+            remote_controller_settings["remote"] = True
+            remote_controller_settings["host"] = self.uiRemoteMainServerHostLineEdit.text()
+            remote_controller_settings["port"] = self.uiRemoteMainServerPortSpinBox.value()
+            remote_controller_settings["protocol"] = self.uiRemoteMainServerProtocolComboBox.currentText().lower()
+            remote_controller_settings["accept_insecure_ssl_certificate"] = False
+            remote_controller_settings["username"] = self.uiRemoteMainServerUserLineEdit.text()
+            remote_controller_settings["password"] = self.uiRemoteMainServerPasswordLineEdit.text()
+            Controller.instance().setSettings(remote_controller_settings)
+            Controller.instance().connect()
+            return Controller.instance().connected()
 
         return True
 
-    def _refreshVMListSlot(self):
-        """
-        Refresh the list of VM available in VMware or VirtualBox.
-        """
-
-        if self.uiVmwareRadioButton.isChecked():
-            Controller.instance().get("/gns3vm/engines/vmware/vms", self._getVMsFromServerCallback, progressText="Retrieving VMware VM list from server...")
-        elif self.uiVirtualBoxRadioButton.isChecked():
-            Controller.instance().get("/gns3vm/engines/virtualbox/vms", self._getVMsFromServerCallback, progressText="Retrieving VirtualBox VM list from server...")
-
-    def _getVMsFromServerCallback(self, result, error=False, **kwargs):
-        """
-        Callback for getVMsFromServer.
-
-        :param progress_dialog: QProgressDialog instance
-        :param result: server response
-        :param error: indicates an error (boolean)
-        """
-
-        if error:
-            QtWidgets.QMessageBox.critical(self, "VM List", "{}".format(result["message"]))
-        else:
-            self.uiVMListComboBox.clear()
-            for vm in result:
-                self.uiVMListComboBox.addItem(vm["vmname"])
-
-            index = self.uiVMListComboBox.findText(self._GNS3VMSettings()["vmname"])
-            if index != -1:
-                self.uiVMListComboBox.setCurrentIndex(index)
-            else:
-                index = self.uiVMListComboBox.findText("GNS3 VM")
-                if index != -1:
-                    self.uiVMListComboBox.setCurrentIndex(index)
-                else:
-                    QtWidgets.QMessageBox.critical(self, "GNS3 VM", "Could not find a VM named 'GNS3 VM', is it imported in VMware or VirtualBox?")
-
     def done(self, result):
         """
         This dialog is closed.
@@ -398,11 +227,8 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
             settings["hide_setup_wizard"] = True
         else:
             local_server_settings = LocalServer.instance().localServerSettings()
-            if local_server_settings["host"] is None:
-                local_server_settings["host"] = DEFAULT_LOCAL_SERVER_HOST
-                LocalServer.instance().updateLocalServerSettings(local_server_settings)
-            settings["hide_setup_wizard"] = self.uiShowCheckBox.isChecked()
-
+            LocalServer.instance().updateLocalServerSettings(local_server_settings)
+            settings["hide_setup_wizard"] = not self.uiShowCheckBox.isChecked()
         self.parentWidget().setSettings(settings)
         super().done(result)
 
@@ -412,20 +238,17 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
         """
 
         current_id = self.currentId()
-        if self.page(current_id) == self.uiLocalServerStatusWizardPage and not self.uiVMRadioButton.isChecked():
+        if self.page(current_id) == self.uiLocalControllerWizardPage and self.uiLocalControllerRadioButton.isChecked():
             return self._pageId(self.uiSummaryWizardPage)
-
-        if self.page(current_id) == self.uiServerWizardPage and self.uiRemoteControllerRadioButton.isChecked():
+        if self.page(current_id) == self.uiControllerWizardPage and self.uiRemoteControllerRadioButton.isChecked():
             return self._pageId(self.uiRemoteControllerWizardPage)
-
-        if self.page(current_id) == self.uiVMWizardPage:
-            return self._pageId(self.uiSummaryWizardPage)
         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

gns3/dialogs/show_readme_dialog.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2020 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 gns3.qt import QtCore, QtGui, QtWidgets
+from gns3.ui.show_readme_dialog_ui import Ui_ShowReadmeDialog
+from gns3.utils import parse_version
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class ShowReadmeDialog(QtWidgets.QDialog, Ui_ShowReadmeDialog):
+
+    def __init__(self, project, path, content=None, parent=None):
+
+        if parent is None:
+            from gns3.main_window import MainWindow
+            parent = MainWindow.instance()
+
+        super().__init__(parent)
+        self.setupUi(self)
+
+        self._project = project
+        self._path = path
+        self.setWindowTitle(project.name() + " " + os.path.basename(path))
+        self.uiRefreshButton.pressed.connect(self._refreshSlot)
+
+        # QTextDocument before Qt version 5.14 doesn't support Markdown
+        if parse_version(QtCore.QT_VERSION_STR) < parse_version("5.14.0") or parse_version(QtCore.PYQT_VERSION_STR) < parse_version("5.14.0"):
+            self._markdown = False
+        else:
+            self._markdown = True
+
+        self._document = QtGui.QTextDocument()
+        self.uiTextBrowser.setDocument(self._document)
+
+        if content:
+            if self._markdown:
+                self._document.setMarkdown(content)
+            else:
+                self._document.setPlainText(content)
+        else:
+            self._refreshSlot()
+
+    def _refreshSlot(self):
+        self._project.get("/files/" + self._path, self._getCallback, raw=True)
+
+    def _getCallback(self, result, error=False, **kwargs):
+
+        if not error:
+            content = result.decode("utf-8", errors="ignore")
+            if self._markdown:
+                self._document.setMarkdown(content)
+            else:
+                self._document.setPlainText(content)

gns3/dialogs/snapshots_dialog.py

@@ -85,11 +85,14 @@ class SnapshotsDialog(QtWidgets.QDialog, Ui_SnapshotsDialog):
 
         snapshot_name, ok = QtWidgets.QInputDialog.getText(self, "Snapshot", "Snapshot name:", QtWidgets.QLineEdit.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)
+            Controller.instance().post(
+                "/projects/{}/snapshots".format(self._project.id()),
+                self._createSnapshotsCallback,
+                {"name": snapshot_name},
+                progress_text="Creation of snapshot '{}' in progress...".format(snapshot_name),
+                timeout=None,
+                wait=True
+            )
 
     def _createSnapshotsCallback(self, result, error=False, server=None, context={}, **kwargs):
         if error:
@@ -139,8 +142,13 @@ class SnapshotsDialog(QtWidgets.QDialog, Ui_SnapshotsDialog):
         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)
+        Controller.instance().post(
+            "/projects/{}/snapshots/{}/restore".format(self._project.id(), snapshot_id),
+            self._restoreSnapshotsCallback,
+            progress_text="Restoring snapshot...",
+            timeout=None,
+            wait=True
+        )
 
     def _restoreSnapshotsCallback(self, result, error=False, server=None, context={}, **kwargs):
 

gns3/dialogs/style_editor_dialog.py

@@ -22,6 +22,8 @@ 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.line_item import LineItem
+from ..items.rectangle_item import RectangleItem
 
 
 class StyleEditorDialog(QtWidgets.QDialog, Ui_StyleEditorDialog):
@@ -48,7 +50,8 @@ class StyleEditorDialog(QtWidgets.QDialog, Ui_StyleEditorDialog):
         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)
+        if True not in list(map(lambda item: isinstance(item, LineItem), items)):
+            self.uiBorderStyleComboBox.addItem("No border", QtCore.Qt.NoPen)
 
         # use the first item in the list as the model
         first_item = items[0]
@@ -70,8 +73,27 @@ class StyleEditorDialog(QtWidgets.QDialog, Ui_StyleEditorDialog):
                                                                                                     self._border_color.green(),
                                                                                                     self._border_color.blue(),
                                                                                                     self._border_color.alpha()))
-        self.uiRotationSpinBox.setValue(first_item.rotation())
+        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.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)
@@ -116,10 +138,18 @@ class StyleEditorDialog(QtWidgets.QDialog, Ui_StyleEditorDialog):
 
         for item in self._items:
             item.setPen(pen)
-            # on multiselection it's possible to select many type of items
+            # 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.setRotation(self.uiRotationSpinBox.value())
 
     def done(self, result):

gns3/dialogs/style_editor_dialog_link.py

@@ -0,0 +1,120 @@
+# -*- 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.uiBorderColorPushButton.clicked.connect(self._setBorderColorSlot)
+        self.uiButtonBox.button(QtWidgets.QDialogButtonBox.Apply).clicked.connect(self._applyPreferencesSlot)
+
+        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("Invisible", QtCore.Qt.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.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.RoundCap, QtCore.Qt.RoundJoin)
+
+        self._link.setPen(pen)
+
+        new_link_style = {}
+        new_link_style["color"] = self._border_color.name()
+        new_link_style["width"] = self.uiBorderWidthSpinBox.value()
+        new_link_style["type"]  = border_style
+        
+        # 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

@@ -25,7 +25,6 @@ import pathlib
 from ..qt import QtCore, QtGui, QtWidgets, qpartial, sip_is_deleted
 from ..qt.qimage_svg_renderer import QImageSvgRenderer
 from ..ui.symbol_selection_dialog_ui import Ui_SymbolSelectionDialog
-from ..local_server import LocalServer
 from ..controller import Controller
 from ..symbol import Symbol
 
@@ -56,7 +55,6 @@ class SymbolSelectionDialog(QtWidgets.QDialog, Ui_SymbolSelectionDialog):
         self.uiCustomSymbolRadioButton.toggled.connect(self._customSymbolToggledSlot)
         self.uiBuiltInSymbolRadioButton.toggled.connect(self._builtInSymbolToggledSlot)
         self.uiSearchLineEdit.textChanged.connect(self._searchTextChangedSlot)
-        self.uiBuiltinSymbolOnlyCheckBox.toggled.connect(self._builtinSymbolOnlyToggledSlot)
         if not SymbolSelectionDialog._symbols_dir:
             SymbolSelectionDialog._symbols_dir = QtCore.QStandardPaths.writableLocation(QtCore.QStandardPaths.PicturesLocation)
 
@@ -64,10 +62,12 @@ class SymbolSelectionDialog(QtWidgets.QDialog, Ui_SymbolSelectionDialog):
             self.uiButtonBox.button(QtWidgets.QDialogButtonBox.Apply).hide()
 
         self.uiBuiltInSymbolRadioButton.setChecked(True)
-        self.uiSymbolListWidget.setFocus()
-        self.uiSymbolListWidget.setIconSize(QtCore.QSize(64, 64))
+        self.uiSymbolTreeWidget.setFocus()
+        self.uiSymbolTreeWidget.setIconSize(QtCore.QSize(64, 64))
         self._symbol_items = []
+        self._parents = {}
 
+        Controller.instance().clearStaticCache()  # TODO: use etag to know when to refresh the cache
         Controller.instance().get("/symbols", self._listSymbolsCallback)
 
     def _listSymbolsCallback(self, result, error=False, **kwargs):
@@ -78,17 +78,24 @@ class SymbolSelectionDialog(QtWidgets.QDialog, Ui_SymbolSelectionDialog):
         self._symbol_items = []
         for symbol in result:
             symbol = Symbol(**symbol)
-            name = os.path.splitext(symbol.filename())[0]
-            item = QtWidgets.QListWidgetItem(self.uiSymbolListWidget)
-            item.setData(QtCore.Qt.UserRole, symbol)
-            self._symbol_items.append(item)
-            item.setText(name)
+            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.ItemIsSelectable)
+                self._parents[theme] = parent
+            else:
+                parent = self._parents[theme]
 
-            image = QtGui.QImage(64, 64, QtGui.QImage.Format_ARGB32)
-            # Set the ARGB to 0 to prevent rendering artifacts
-            image.fill(0x00000000)
-            icon = QtGui.QIcon(QtGui.QPixmap.fromImage(image))
-            item.setIcon(icon)
+            name = os.path.splitext(symbol.filename())[0]
+            item = QtWidgets.QTreeWidgetItem(parent)
+            item.setData(0, QtCore.Qt.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):
@@ -99,13 +106,13 @@ class SymbolSelectionDialog(QtWidgets.QDialog, Ui_SymbolSelectionDialog):
                 image.fill(0x00000000)
                 svg_renderer.render(QtGui.QPainter(image))
                 icon = QtGui.QIcon(QtGui.QPixmap.fromImage(image))
-                item.setIcon(icon)
+                item.setIcon(0, icon)
 
             Controller.instance().getStatic(symbol.url(), qpartial(render, item))
-        self.adjustSize()
 
-    def _builtinSymbolOnlyToggledSlot(self, checked):
-        self._filter()
+        for parent in self._parents.values():
+            parent.sortChildren(0, QtCore.Qt.AscendingOrder)
+        self.adjustSize()
 
     def _searchTextChangedSlot(self, text):
         self._filter()
@@ -116,13 +123,13 @@ class SymbolSelectionDialog(QtWidgets.QDialog, Ui_SymbolSelectionDialog):
         """
         text = self.uiSearchLineEdit.text()
         for item in self._symbol_items:
-            if self.uiBuiltinSymbolOnlyCheckBox.isChecked() and not item.data(QtCore.Qt.UserRole).builtin():
-                item.setHidden(True)
+            # if not item.data(0, QtCore.Qt.UserRole).builtin():
+            #     item.setHidden(True)
+            # else:
+            if not text.strip() or text.strip().lower() in item.text(0).lower():
+                item.setHidden(False)
             else:
-                if len(text.strip()) == 0 or text.strip().lower() in item.text().lower():
-                    item.setHidden(False)
-                else:
-                    item.setHidden(True)
+                item.setHidden(True)
 
     def _customSymbolToggledSlot(self, checked):
         """
@@ -158,16 +165,18 @@ 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)
         return True
 
     def getSymbol(self):
 
-        if self.uiSymbolListWidget.isEnabled():
-            current = self.uiSymbolListWidget.currentItem()
-            if current:
-                return current.data(QtCore.Qt.UserRole).id()
+        if self.uiSymbolTreeWidget.isEnabled():
+            current = self.uiSymbolTreeWidget.currentItem()
+            if current and current.parent():
+                return current.data(0, QtCore.Qt.UserRole).id()
         else:
             return os.path.basename(self.uiSymbolLineEdit.text())
         return None
@@ -175,14 +184,21 @@ class SymbolSelectionDialog(QtWidgets.QDialog, Ui_SymbolSelectionDialog):
     def _symbolBrowserSlot(self):
 
         # supported image file formats
-        file_formats = "Image files (*.svg *.bmp *.jpeg *.jpg *.pbm *.pgm *.png *.ppm *.xbm *.xpm *.gif);;All files (*.*)"
+        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)
         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)
+        Controller.instance().post(
+            "/symbols/" + symbol_id + "/raw",
+            qpartial(self._finishSymbolUpload, path),
+            body=pathlib.Path(path),
+            progress_text="Uploading {}".format(symbol_id),
+            timeout=None,
+            wait=True
+        )
 
     def _finishSymbolUpload(self, path, result, error=False, **kwargs):
         if error:

gns3/dialogs/text_editor_dialog.py

@@ -44,7 +44,7 @@ class TextEditorDialog(QtWidgets.QDialog, Ui_TextEditorDialog):
         # use the first item in the list as the model
         first_item = items[0]
         self._setColor(first_item.defaultTextColor())
-        self.uiRotationSpinBox.setValue(first_item.rotation())
+        self.uiRotationSpinBox.setValue(int(first_item.rotation()))
         self.uiPlainTextEdit.setPlainText(first_item.toPlainText())
         self.uiPlainTextEdit.setFont(first_item.font())
 

gns3/dialogs/vm_with_images_wizard.py

@@ -88,9 +88,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()["server"], self.uiNameLineEdit.text() + image_suffix)
-        if QtWidgets.QDialog.Accepted == create_dialog.exec_():
-            line_edit.setText(create_dialog.uiLocationLineEdit.text())
+
+        create_dialog = create_image_wizard(self, Controller.instance(), self.uiNameLineEdit.text() + image_suffix)
+        if create_dialog.exec_() == QtWidgets.QDialog.Accepted:
+            line_edit.setText(create_dialog.uiDiskFilenameLineEdit.text())
 
     def _imageBrowserSlot(self, line_edit, image_selector):
         """
@@ -135,14 +136,17 @@ class VMWithImagesWizard(VMWizard):
             if create_button:
                 create_button.show()
 
-    def loadImagesList(self, endpoint):
+    def loadImagesList(self, image_type):
         """
-        Fill the list box with available Images"
+        Fill the list box with available images
 
-        :param endpoint: server endpoint with the list of Images
+        :param image_type: image type (qemu, iou or ios)
         """
 
-        Controller.instance().getCompute(endpoint, self._compute_id, self._getImagesFromServerCallback)
+        params = None
+        if image_type:
+            params = {"image_type": image_type}
+        Controller.instance().get("/images", self._getImagesFromServerCallback, params=params)
 
     def _getImagesFromServerCallback(self, result, error=False, **kwargs):
         """
@@ -179,7 +183,7 @@ class VMWithImagesWizard(VMWizard):
             if self._widgetOnCurrentPage(combo_box):
                 combo_box.clear()
                 for vm in result:
-                    combo_box.addItem(vm["path"], vm)
+                    combo_box.addItem(vm["filename"], vm)
 
     def _widgetOnCurrentPage(self, widget):
         """

gns3/dialogs/vm_wizard.py

@@ -37,6 +37,7 @@ class VMWizard(QtWidgets.QWizard):
         self.setModal(True)
 
         self._devices = devices
+        self._allow_dynamic_compute_allocation = True
         self._local_server_disable = False
 
         self.setWizardStyle(QtWidgets.QWizard.ModernStyle)
@@ -102,6 +103,8 @@ class VMWizard(QtWidgets.QWizard):
             if hasattr(self, "uiVMRadioButton"):
                 self.uiVMRadioButton.setEnabled(False)
             self.uiLocalRadioButton.setEnabled(False)
+            if self._allow_dynamic_compute_allocation:
+                self.uiRemoteServersComboBox.addItem("Any server", None)
             for compute in ComputeManager.instance().computes():
                 if compute.id() == "local":
                     self.uiLocalRadioButton.setEnabled(True)

gns3/http_client_error.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python
+#
+# Copyright (C) 2021 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/>.
+
+
+class HttpClientError(Exception):
+    def __init__(self, message: str):
+        super().__init__()
+        self._message = message
+
+    def __repr__(self):
+        return self._message
+
+    def __str__(self):
+        return self._message
+
+
+class HttpClientNotFoundError(HttpClientError):
+    def __init__(self, message: str):
+        super().__init__(message)
+
+
+class HttpClientCancelledRequestError(HttpClientError):
+    def __init__(self, message: str):
+        super().__init__(message)
+
+
+class HttpClientBadRequestError(HttpClientError):
+    def __init__(self, message: str):
+        super().__init__(message)
+
+
+class HttpClientUnauthorizedError(HttpClientError):
+    def __init__(self, message: str):
+        super().__init__(message)
+
+
+class HttpClientForbiddenError(HttpClientError):
+    def __init__(self, message: str):
+        super().__init__(message)
+
+
+class HttpClientTimeoutError(HttpClientError):
+    def __init__(self, message: str):
+        super().__init__(message)

gns3/image_manager.py

@@ -20,11 +20,10 @@ import copy
 import pathlib
 
 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.http_client_error import HttpClientError, HttpClientCancelledRequestError
 from gns3.registry.image import Image
 
 
@@ -69,7 +68,7 @@ class ImageManager:
         """
 
         if (server and server != "local") or Controller.instance().isRemote():
-            return self._uploadImageToRemoteServer(source_path, server, node_type)
+            return self._uploadImageToRemoteServer(source_path, node_type, parent)
         else:
             destination_directory = self.getDirectoryForType(node_type)
             destination_path = os.path.join(destination_directory, os.path.basename(source_path))
@@ -115,27 +114,45 @@ class ImageManager:
                         source_path = destination_path
             return source_path
 
-    def _uploadImageToRemoteServer(self, path, server, node_type):
+    def _uploadImageToRemoteServer(self, path, node_type, parent):
         """
         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
         :returns path: Final path
         """
 
         if node_type == 'QEMU':
-            upload_endpoint = '/qemu/images'
+            image_type = 'qemu'
         elif node_type == 'IOU':
-            upload_endpoint = '/iou/images'
+            image_type = 'iou'
         elif node_type == 'DYNAMIPS':
-            upload_endpoint = '/dynamips/images'
+            image_type = 'ios'
         else:
             raise Exception('Invalid node 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)
+
+        try:
+            Controller.instance().post(
+                f"/images/upload/{filename}",
+                callback=None,
+                params={"image_type": image_type},
+                body=pathlib.Path(path),
+                progress_text="Uploading {}".format(filename),
+                timeout=None,
+                wait=True
+            )
+        except HttpClientCancelledRequestError:
+            return
+        except HttpClientError as e:
+            QtWidgets.QMessageBox.critical(
+                parent,
+                "Image upload",
+                f"Could not upload image {filename}: {e}"
+            )
+
         return filename
 
     def _getRelativeImagePath(self, path, node_type):
@@ -164,7 +181,7 @@ class ImageManager:
         :returns: path to the default images directory
         """
 
-        return copy.copy(LocalServerConfig.instance().loadSettings("Server", LOCAL_SERVER_SETTINGS)['images_path'])
+        return copy.copy(Controller.instance().settings()['images_path'])
 
     def getDirectoryForType(self, node_type):
         """
@@ -176,7 +193,7 @@ class ImageManager:
         if node_type == 'DYNAMIPS':
             return os.path.join(self.getDirectory(), 'IOS')
         else:
-            return os.path.join(self.getDirectory(), node_type)
+            return os.path.join(self.getDirectory(), node_type.upper())
 
     @staticmethod
     def instance():

gns3/image_upload_manager.py

@@ -15,10 +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 os
 import pathlib
-import urllib.parse
 
-from gns3.http_client import HTTPClient
+from gns3.http_client_error import HttpClientError, HttpClientCancelledRequestError
+from gns3.qt import QtWidgets
+from gns3.registry.image import Image
+from gns3.controller import Controller
 
 import logging
 log = logging.getLogger(__name__)
@@ -26,66 +29,42 @@ log = logging.getLogger(__name__)
 
 class ImageUploadManager(object):
     """
-    Manager over the image upload. Encapsulates file uploads to computes or via controller.
+    Manager over the image upload
     """
 
-    def __init__(self, image, controller, compute_id, callback=None, directFileUpload=False):
+    def __init__(self, image: Image, controller: Controller, parent: QtWidgets.QWidget):
+
         self._image = image
-        self._compute_id = compute_id
-        self._callback = callback
-        self._directFileUpload = directFileUpload
         self._controller = controller
+        self._parent = parent
 
-    def upload(self):
-        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 upload(self) -> bool:
 
-    def _getComputePath(self):
-        return '/{emulator}/images/{filename}'.format(
-            emulator=self._image.emulator, filename=self._image.filename)
+        if not os.path.exists(self._image.path):
+            log.error("Image '{}' could not be found".format(self._image.path))
+            return False
+        return self._fileUploadToController()
 
-    def _onLoadEndpointCallback(self, result, error=False, **kwargs):
-        if error:
-            if "message" in result:
-                log.error("Error while getting endpoint: {}".format(result["message"]))
-            return
+    def _fileUploadToController(self) -> bool:
 
-        # 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.info("Uploading file to compute: {}".format(endpoint))
-
-        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),
-            progressText="Uploading {}".format(self._image.filename), timeout=None, prefix="")
-
-    def _fileUploadToController(self):
-        log.info("Uploading file to controller: {}".format(self._getComputePath()))
-        self._controller.postCompute(
-            self._getComputePath(), self._compute_id, self._callback, body=pathlib.Path(self._image.path),
-            progressText="Uploading {}".format(self._image.filename), timeout=None)
+        log.info("Uploading image '{}' to controller".format(self._image.filename))
+        try:
+            self._controller.post(
+                f"/images/upload/{self._image.filename}",
+                callback=None,
+                body=pathlib.Path(self._image.path),
+                context={"image_path": self._image.path},
+                progress_text="Uploading {}".format(self._image.filename),
+                timeout=None,
+                wait=True
+            )
+        except HttpClientCancelledRequestError:
+            return False
+        except HttpClientError as e:
+            QtWidgets.QMessageBox.critical(
+                self._parent,
+                "Image upload to controller",
+                f"Could not upload image {self._image.filename}: {e}"
+            )
+            return False
+        return True

gns3/items/drawing_item.py

@@ -27,7 +27,7 @@ log = logging.getLogger(__name__)
 class DrawingItem:
     # Map QT stroke to SVG style
     QT_DASH_TO_SVG = {
-        QtCore.Qt.SolidLine: "",
+        QtCore.Qt.SolidLine: "none",
         QtCore.Qt.NoPen: None,
         QtCore.Qt.DashLine: "25, 25",
         QtCore.Qt.DotLine: "5, 25",
@@ -41,9 +41,11 @@ class DrawingItem:
     Base class for non emulation item
     """
 
-    def __init__(self, project=None, pos=None, drawing_id=None, svg=None, z=0, rotation=0, **kws):
+    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.ItemIsMovable | QtWidgets.QGraphicsItem.ItemIsFocusable | QtWidgets.QGraphicsItem.ItemIsSelectable | QtWidgets.QGraphicsItem.ItemSendsGeometryChanges)
@@ -65,6 +67,8 @@ class DrawingItem:
         if rotation:
             self.setRotation(rotation)
 
+        self.setLocked(locked)
+
     def drawing_id(self):
         return self._id
 
@@ -89,7 +93,7 @@ class DrawingItem:
 
     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)
+            self._project.put("/drawings/" + self._id, self.updateDrawingCallback, body=self.__json__(), show_progress=False)
 
     @qslot
     def updateDrawingCallback(self, result, error=False, **kwargs):
@@ -106,6 +110,7 @@ class DrawingItem:
             return False
         self.setPos(QtCore.QPoint(result["x"], result["y"]))
         self.setZValue(result["z"])
+        self.setLocked(result["locked"])
         self.setRotation(result["rotation"])
         if "svg" in result:
             self.fromSvg(result["svg"])
@@ -131,6 +136,9 @@ class DrawingItem:
             if self.rotation() < 360.0:
                 self.setRotation(self.rotation() + 1)
                 return True
+        elif modifiers & QtCore.Qt.AltModifier:
+            self._allow_snap_to_grid = False
+            return True
         return False
 
     def keyPressEvent(self, event):
@@ -143,12 +151,22 @@ class DrawingItem:
         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()
@@ -158,25 +176,29 @@ class DrawingItem:
             self._hash_svg = hash_svg
         return data
 
-    def setZValue(self, value):
+    def locked(self):
         """
-        Sets a new Z value.
+        Is the drawing locked
+        """
+
+        return self._locked
+
+    def setLocked(self, locked):
+        """
+        Sets the locked value.
 
         :param value: Z value
         """
 
-        QtWidgets.QGraphicsItem.setZValue(self, value)
-
-        if self.zValue() < 0:
-            self.setFlag(self.ItemIsSelectable, False)
+        if locked is True:
             self.setFlag(self.ItemIsMovable, False)
         else:
-            self.setFlag(self.ItemIsSelectable, True)
             self.setFlag(self.ItemIsMovable, True)
+        self._locked = locked
 
     def deleting(self):
         """
-        Is the link being deleted
+        Is the drawing being deleted
         """
 
         return self._deleting
@@ -203,14 +225,12 @@ class DrawingItem:
             self._project.delete("/drawings/" + self._id, None, body=self.__json__())
 
     def itemChange(self, change, value):
-        if change == QtWidgets.QGraphicsItem.ItemPositionHasChanged and self.isActive() and self._main_window.uiSnapToGridAction.isChecked():
-            grid_size = self._graphics_view.gridSize()
-            mid_x = self.boundingRect().width() / 2
-            tmp_x = (grid_size * round((self.x() + mid_x) / grid_size)) - mid_x
-            mid_y = self.boundingRect().height() / 2
-            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)
+
+        if change == QtWidgets.QGraphicsItem.ItemPositionChange and self._main_window.uiSnapToGridAction.isChecked() \
+                and self._allow_snap_to_grid:
+            grid_size = self._graphics_view.drawingGridSize()
+            value.setX(grid_size * round(value.x() / grid_size))
+            value.setY(grid_size * round(value.y() / grid_size))
 
         if change == QtWidgets.QGraphicsItem.ItemSelectedChange:
             if not value:
@@ -238,7 +258,7 @@ class DrawingItem:
         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.drawRect(QtCore.QRectF((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)

gns3/items/ellipse_item.py

@@ -22,7 +22,7 @@ Graphical representation of an ellipse on the QGraphicsScene.
 import math
 import xml.etree.ElementTree as ET
 
-from ..qt import QtCore, QtGui, QtWidgets
+from ..qt import QtWidgets
 from .shape_item import ShapeItem
 
 
@@ -48,13 +48,6 @@ class EllipseItem(QtWidgets.QGraphicsEllipseItem, ShapeItem):
         super().paint(painter, option, widget)
         self.drawLayerInfo(painter)
 
-    def setZValue(self, value):
-        """
-        Sets Z value of the item
-        :param value: z layer
-        """
-        return ShapeItem.setZValue(self, value)
-
     def toSvg(self):
         """
         Return an SVG version of the shape

gns3/items/ethernet_link_item.py

@@ -1,5 +1,6 @@
 # -*- 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
@@ -21,7 +22,7 @@ Graphical representation of an Ethernet link for QGraphicsScene.
 
 from ..qt import QtCore, QtGui, QtWidgets
 from .link_item import LinkItem
-from .note_item import NoteItem
+from .label_item import LabelItem
 from ..ports.port import Port
 
 
@@ -51,10 +52,16 @@ class EthernetLinkItem(LinkItem):
 
         LinkItem.adjust(self)
 
-        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))
+        try:
+            if self._hovered:
+                self.setPen(QtGui.QPen(QtCore.Qt.red, self._link._link_style["width"] + 1, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin))
+            else:
+                self.setPen(QtGui.QPen(QtGui.QColor(self._link._link_style["color"]), self._link._link_style["width"], self._link._link_style["type"], QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin))
+        except:
+            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(QtGui.QColor("#000000"), self._pen_width, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin))
 
         # draw a line between nodes
         path = QtGui.QPainterPath(self.source)
@@ -141,17 +148,18 @@ class EthernetLinkItem(LinkItem):
             source_port_label = self._source_port.label()
 
             if source_port_label is None:
-                source_port_label = NoteItem(self._source_item)
+                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(source_port_label.ItemIsMovable, not self._source_item.locked())
                 source_port_label.show()
             else:
                 source_port_label.hide()
 
-            if self._settings["draw_link_status_points"]:
+            if self._settings["draw_link_status_points"] and self.pen().style() != QtCore.Qt.NoPen:
                 painter.drawPoint(point1)
 
             if self._link.suspended() or self._destination_port.status() == Port.suspended:
@@ -183,17 +191,18 @@ class EthernetLinkItem(LinkItem):
             destination_port_label = self._destination_port.label()
 
             if destination_port_label is None:
-                destination_port_label = NoteItem(self._destination_item)
+                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(destination_port_label.ItemIsMovable, not self._destination_item.locked())
                 destination_port_label.show()
             else:
                 destination_port_label.hide()
 
-            if self._settings["draw_link_status_points"]:
+            if self._settings["draw_link_status_points"] and self.pen().style() != QtCore.Qt.NoPen:
                 painter.drawPoint(point2)
 
         self._drawSymbol()

gns3/items/image_item.py

@@ -52,6 +52,9 @@ class ImageItem(QtSvg.QGraphicsSvgItem, DrawingItem):
         if svg:
             svg = self.fromSvg(svg)
 
+        if 'z' in kws.keys():
+            self.setZValue(kws['z'])
+
     def paint(self, painter, option, widget=None):
         """
         Paints the contents of an item in local coordinates.
@@ -64,13 +67,6 @@ class ImageItem(QtSvg.QGraphicsSvgItem, DrawingItem):
         super().paint(painter, option, widget)
         self.drawLayerInfo(painter)
 
-    def setZValue(self, value):
-        """
-        Sets Z value of the item
-        :param value: z layer
-        """
-        return DrawingItem.setZValue(self, value)
-
     def fromSvg(self, svg):
         renderer = QImageSvgRenderer(svg)
         self.setSharedRenderer(renderer)

gns3/items/label_item.py

@@ -15,20 +15,17 @@
 # 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 NoteItem(QtWidgets.QGraphicsTextItem):
+class LabelItem(QtWidgets.QGraphicsTextItem):
     """
-    Text note for the QGraphicsView.
+    Label for links and nodes.
 
     :param parent: optional parent
     """
+
     item_unselected_signal = QtCore.Signal()
 
     show_layer = False
@@ -45,8 +42,7 @@ class NoteItem(QtWidgets.QGraphicsTextItem):
         qt_font.fromString(view_settings["default_label_font"])
         self.setDefaultTextColor(QtGui.QColor(view_settings["default_label_color"]))
         self.setFont(qt_font)
-        self.setFlag(self.ItemIsMovable)
-        self.setFlag(self.ItemIsSelectable)
+        self.setFlags(QtWidgets.QGraphicsItem.ItemIsMovable | QtWidgets.QGraphicsItem.ItemIsSelectable)
         self.setZValue(2)
         self._editable = True
 
@@ -169,32 +165,17 @@ class NoteItem(QtWidgets.QGraphicsTextItem):
         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.drawRect(QtCore.QRectF((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)
 
-    def setZValue(self, value):
-        """
-        Sets a new Z value.
-
-        :param value: Z 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 setStyle(self, styles):
+    def setStyle(self, new_style):
         """
         Set text style using a SVG style
         """
         font = QtGui.QFont()
-        for style in styles.split(";"):
+        for style in new_style.split(";"):
             if ":" in style:
                 key, val = style.split(":")
                 key = key.strip()

gns3/items/line_item.py

@@ -63,13 +63,6 @@ class LineItem(QtWidgets.QGraphicsLineItem, DrawingItem):
         super().paint(painter, option, widget)
         self.drawLayerInfo(painter)
 
-    def setZValue(self, value):
-        """
-        Sets Z value of the item
-        :param value: z layer
-        """
-        return DrawingItem.setZValue(self, value)
-
     def toSvg(self):
         """
         Return an SVG version of the shape
@@ -126,8 +119,8 @@ class LineItem(QtWidgets.QGraphicsLineItem, DrawingItem):
         :param event: QGraphicsSceneHoverEvent instance
         """
 
-        # objects on the background layer don't need cursors
-        if self.zValue() >= 0:
+        # locked objects don't need cursors
+        if not self.locked():
 
             if self._isHorizontalLine():
                 if event.pos().x() > (self.line().x2() - self._border):
@@ -218,6 +211,6 @@ class LineItem(QtWidgets.QGraphicsLineItem, DrawingItem):
         :param event: QGraphicsSceneHoverEvent instance
         """
 
-        # objects on the background layer don't need cursors
-        if self.zValue() >= 0:
+        # locked objects don't need cursors
+        if not self.locked():
             self._graphics_view.setCursor(QtCore.Qt.ArrowCursor)

gns3/items/link_item.py

@@ -25,6 +25,8 @@ from ..qt import QtCore, QtGui, QtWidgets, QtSvg, qslot, sip_is_deleted
 
 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
 
 
 class SvgIconItem(QtSvg.QGraphicsSvgItem):
@@ -35,7 +37,8 @@ class SvgIconItem(QtSvg.QGraphicsSvgItem):
 
     def mousePressEvent(self, event):
 
-        self.parentItem().mousePressEvent(event)
+        if self.parentItem():
+            self.parentItem().mousePressEvent(event)
         event.accept()
 
 
@@ -135,12 +138,33 @@ class LinkItem(QtWidgets.QGraphicsPathItem):
     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._link.deleteLink()
 
+    def reset(self):
+        """
+        Reset this link
+        """
+        self._link.resetLink()
+
     def link(self):
         """
         Returns the link attached to this link item.
@@ -222,14 +246,14 @@ class LinkItem(QtWidgets.QGraphicsPathItem):
         if not self._link.capturing():
             # start capture
             start_capture_action = QtWidgets.QAction("Start capture", menu)
-            start_capture_action.setIcon(QtGui.QIcon(':/icons/capture-start.svg'))
+            start_capture_action.setIcon(get_icon('capture-start.svg'))
             start_capture_action.triggered.connect(self._startCaptureActionSlot)
             menu.addAction(start_capture_action)
 
         if self._link.capturing():
             # stop capture
             stop_capture_action = QtWidgets.QAction("Stop capture", menu)
-            stop_capture_action.setIcon(QtGui.QIcon(':/icons/capture-stop.svg'))
+            stop_capture_action.setIcon(get_icon('capture-stop.svg'))
             stop_capture_action.triggered.connect(self._stopCaptureActionSlot)
             menu.addAction(stop_capture_action)
 
@@ -248,25 +272,37 @@ class LinkItem(QtWidgets.QGraphicsPathItem):
         if self._link.suspended() is False:
             # Edit filters
             filter_action = QtWidgets.QAction("Packet filters", menu)
-            filter_action.setIcon(QtGui.QIcon(':/icons/filter.svg'))
+            filter_action.setIcon(get_icon('filter.svg'))
             filter_action.triggered.connect(self._filterActionSlot)
             menu.addAction(filter_action)
 
             # Suspend link
             suspend_action = QtWidgets.QAction("Suspend", menu)
-            suspend_action.setIcon(QtGui.QIcon(':/icons/pause.svg'))
+            suspend_action.setIcon(get_icon('pause.svg'))
             suspend_action.triggered.connect(self._suspendActionSlot)
             menu.addAction(suspend_action)
         else:
             # Resume link
             resume_action = QtWidgets.QAction("Resume", menu)
-            resume_action.setIcon(QtGui.QIcon(':/icons/start.svg'))
+            resume_action.setIcon(get_icon('start.svg'))
             resume_action.triggered.connect(self._suspendActionSlot)
             menu.addAction(resume_action)
 
+        # reset
+        reset_action = QtWidgets.QAction("Reset", menu)
+        reset_action.setIcon(get_icon('reload.svg'))
+        reset_action.triggered.connect(self._resetActionSlot)
+        menu.addAction(reset_action)
+
+        # style
+        style_action = QtWidgets.QAction("Style", menu)
+        style_action.setIcon(get_icon("node_conception.svg"))
+        style_action.triggered.connect(self._styleActionSlot)
+        menu.addAction(style_action)
+
         # delete
         delete_action = QtWidgets.QAction("Delete", menu)
-        delete_action.setIcon(QtGui.QIcon(':/icons/delete.svg'))
+        delete_action.setIcon(get_icon('delete.svg'))
         delete_action.triggered.connect(self._deleteActionSlot)
         menu.addAction(delete_action)
 
@@ -278,23 +314,31 @@ class LinkItem(QtWidgets.QGraphicsPathItem):
         :param: QGraphicsSceneMouseEvent instance
         """
 
-        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
+        if event.button() == QtCore.Qt.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.KeyPress, QtCore.Qt.Key_Escape, QtCore.Qt.NoModifier)
+            QtWidgets.QApplication.sendEvent(MainWindow.instance(), key)
+            return
+        else:
+            super().mousePressEvent(event)
 
-            if not sip_is_deleted(self):
-                # create the contextual menu
-                self.setAcceptHoverEvents(False)
-                menu = QtWidgets.QMenu()
-                self.populateLinkContextualMenu(menu)
-                menu.exec_(QtGui.QCursor.pos())
-                self.setAcceptHoverEvents(True)
-                self._hovered = False
-                self.adjust()
+    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()
+            self.populateLinkContextualMenu(menu)
+            menu.exec_(QtGui.QCursor.pos())
+            self.setAcceptHoverEvents(True)
+            self.setHovered(False)
 
     def keyPressEvent(self, event):
         """
@@ -308,6 +352,14 @@ class LinkItem(QtWidgets.QGraphicsPathItem):
             self._deleteActionSlot()
             return
 
+    def _resetActionSlot(self):
+        """
+        Slot to receive events from the reset action in the
+        contextual menu.
+        """
+
+        self.reset()
+
     def _deleteActionSlot(self):
         """
         Slot to receive events from the delete action in the

gns3/items/node_item.py

@@ -23,7 +23,7 @@ from ..qt import sip
 
 from ..qt import QtCore, QtGui, QtWidgets, QtSvg, qslot
 from ..qt.qimage_svg_renderer import QImageSvgRenderer
-from .note_item import NoteItem
+from .label_item import LabelItem
 from ..symbol import Symbol
 from ..controller import Controller
 
@@ -50,6 +50,8 @@ class NodeItem(QtSvg.QGraphicsSvgItem):
         # 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.
@@ -59,7 +61,6 @@ class NodeItem(QtSvg.QGraphicsSvgItem):
         self._node_label = None
 
         self.setPos(QtCore.QPoint(self._node.x(), self._node.y()))
-        self.setZValue(self._node.z())
 
         # Temporary symbol during loading
         renderer = QImageSvgRenderer(":/icons/reload.svg")
@@ -79,6 +80,10 @@ class NodeItem(QtSvg.QGraphicsSvgItem):
         self.setFlag(QtWidgets.QGraphicsItem.ItemSendsGeometryChanges)
         self.setAcceptHoverEvents(True)
 
+        # update z value and locked state
+        self.setLocked(self._node.locked())
+        self.setZValue(self._node.z())
+
         # connect signals to know about some events
         # e.g. when the node has been started, stopped or suspended etc.
         node.created_signal.connect(self.createdSlot)
@@ -99,26 +104,19 @@ class NodeItem(QtSvg.QGraphicsSvgItem):
 
         from ..main_window import MainWindow
         self._main_window = MainWindow.instance()
-        if self._main_window.uiSnapToGridAction.isChecked():
-            self._snapToGrid()
         self._settings = self._main_window.uiGraphicsView.settings()
 
         if node.initialized():
             self.createdSlot(node.id())
 
-    def _snapToGrid(self):
-
-        grid_size = self._main_window.uiGraphicsView.gridSize()
-        mid_x = self.boundingRect().width() / 2
-        x = (grid_size * round((self.x() + mid_x) / grid_size)) - mid_x
-        mid_y = self.boundingRect().height() / 2
-        y = (grid_size * round((self.y() + mid_y) / grid_size)) - mid_y
-        self.setPos(x, y)
+        if self._main_window.uiSnapToGridAction.isChecked():
+            self.setPos(QtCore.QPointF(self._node.x() + 0.1, self._node.y()))
 
     def updateNode(self):
         """
         Sync change to the node
         """
+
         self._node.setGraphics(self)
 
     @qslot
@@ -269,7 +267,7 @@ class NodeItem(QtSvg.QGraphicsSvgItem):
         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()
 
         # update the link tooltips in case the
@@ -362,7 +360,7 @@ class NodeItem(QtSvg.QGraphicsSvgItem):
         """
 
         if not self._node_label:
-            self._node_label = NoteItem(self)
+            self._node_label = LabelItem(self)
             self._node_label.item_unselected_signal.connect(self._labelUnselectedSlot)
             self._node_label.setEditable(False)
             self._updateLabel()
@@ -370,7 +368,7 @@ class NodeItem(QtSvg.QGraphicsSvgItem):
 
     def _updateLabel(self):
         """
-        Update the label using the informations stored in the node
+        Update the label using the information stored in the node
         """
         if not self._node_label:
             return
@@ -379,15 +377,22 @@ class NodeItem(QtSvg.QGraphicsSvgItem):
 
         if self._node_label.toPlainText() != label_data["text"]:
             self._node_label.setPlainText(label_data["text"])
-        self._node_label.setStyle(label_data.get("style", ""))
+
+        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(self.ItemIsMovable, False)
+
         if label_data["x"] is None:
             self._centerLabel()
             self.updateNode()
         else:
             self._node_label.setPos(label_data["x"], label_data["y"])
 
-    def connectToPort(self, unavailable_ports=[]):
+    def connectToPort(self, pos, unavailable_ports=[]):
         """
         Shows a contextual menu for the user to choose port or auto-select one.
 
@@ -435,7 +440,10 @@ class NodeItem(QtSvg.QGraphicsSvgItem):
                 menu.addAction(QtGui.QIcon(':/icons/led_green.svg'), port_object.name())
 
         menu.triggered.connect(self.selectedPortSlot)
-        menu.exec_(QtGui.QCursor.pos())
+        # add some delay before showing the menu
+        # https://github.com/GNS3/gns3-gui/issues/3169
+        QtCore.QThread.msleep(100)
+        menu.exec_(pos)
         return self._selected_port
 
     def selectedPortSlot(self, action):
@@ -462,8 +470,9 @@ class NodeItem(QtSvg.QGraphicsSvgItem):
         :param value: value of the change
         """
 
-        if change == QtWidgets.QGraphicsItem.ItemPositionChange and self.isActive() and self._main_window.uiSnapToGridAction.isChecked():
-            grid_size = self._main_window.uiGraphicsView.gridSize()
+        if change == QtWidgets.QGraphicsItem.ItemPositionChange and self._main_window.uiSnapToGridAction.isChecked() \
+                and self._allow_snap_to_grid:
+            grid_size = self._main_window.uiGraphicsView.nodeGridSize()
             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
@@ -503,7 +512,7 @@ class NodeItem(QtSvg.QGraphicsSvgItem):
             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.drawRect(QtCore.QRectF((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
@@ -521,20 +530,52 @@ class NodeItem(QtSvg.QGraphicsSvgItem):
         """
 
         super().setZValue(value)
-        if self.zValue() < 0:
-            self.setFlag(self.ItemIsSelectable, False)
+        for link in self._links:
+            link.adjust()
+
+    def keyPressEvent(self, event):
+        """
+        Handles all key press events
+
+        :param event: QKeyEvent
+        """
+
+        if event.modifiers() & QtCore.Qt.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(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()
+        self._locked = locked
 
     def hoverEnterEvent(self, event):
         """

gns3/items/rectangle_item.py

@@ -32,8 +32,22 @@ class RectangleItem(QtWidgets.QGraphicsRectItem, ShapeItem):
     """
 
     def __init__(self, width=200, height=100, **kws):
+        self._rx = 0
+        self._ry = 0
         super().__init__(width=width, height=height, **kws)
 
+    def setHorizontalCornerRadius(self, radius: int):
+        self._rx = radius
+
+    def horizontalCornerRadius(self):
+        return self._rx
+
+    def setVerticalCornerRadius(self, radius: int):
+        self._ry = radius
+
+    def verticalCornerRadius(self):
+        return self._ry
+
     def paint(self, painter, option, widget=None):
         """
         Paints the contents of an item in local coordinates.
@@ -43,16 +57,11 @@ class RectangleItem(QtWidgets.QGraphicsRectItem, ShapeItem):
         :param widget: QWidget instance
         """
 
-        super().paint(painter, option, widget)
+        painter.setPen(self.pen())
+        painter.setBrush(self.brush())
+        painter.drawRoundedRect(self.rect(), self._rx, self._ry)
         self.drawLayerInfo(painter)
 
-    def setZValue(self, value):
-        """
-        Sets Z value of the item
-        :param value: z layer
-        """
-        return ShapeItem.setZValue(self, value)
-
     def toSvg(self):
         """
         Return an SVG version of the shape
@@ -64,7 +73,27 @@ class RectangleItem(QtWidgets.QGraphicsRectItem, ShapeItem):
         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)

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 .note_item import NoteItem
+from .label_item import LabelItem
 from ..ports.port import Port
 
 
@@ -50,10 +50,16 @@ class SerialLinkItem(LinkItem):
 
         LinkItem.adjust(self)
 
-        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))
+        try:
+            if self._hovered:
+                self.setPen(QtGui.QPen(QtCore.Qt.red, self._link._link_style["width"] + 1, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin))
+            else:
+                self.setPen(QtGui.QPen(QtGui.QColor(self._link._link_style["color"]), self._link._link_style["width"], self._link._link_style["type"], QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin))
+        except:
+            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)
@@ -130,17 +136,18 @@ class SerialLinkItem(LinkItem):
 
             source_port_label = self._source_port.label()
             if source_port_label is None:
-                source_port_label = NoteItem(self._source_item)
+                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(source_port_label.ItemIsMovable, not self._source_item.locked())
                 source_port_label.show()
             else:
                 source_port_label.hide()
 
-            if self._settings["draw_link_status_points"]:
+            if self._settings["draw_link_status_points"] and self.pen().style() != QtCore.Qt.NoPen:
                 painter.drawPoint(self.source_point)
 
             # destination point color
@@ -161,17 +168,18 @@ class SerialLinkItem(LinkItem):
             destination_port_label = self._destination_port.label()
 
             if destination_port_label is None:
-                destination_port_label = NoteItem(self._destination_item)
+                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(destination_port_label.ItemIsMovable, not self._destination_item.locked())
                 destination_port_label.show()
             else:
                 destination_port_label.hide()
 
-            if self._settings["draw_link_status_points"]:
+            if self._settings["draw_link_status_points"] and self.pen().style() != QtCore.Qt.NoPen:
                 painter.drawPoint(self.destination_point)
 
         self._drawSymbol()

gns3/items/shape_item.py

@@ -40,6 +40,7 @@ class ShapeItem(DrawingItem):
         self.setAcceptHoverEvents(True)
         self._border = 5
         self._edge = None
+        self._originally_movable = True
 
         if svg is None:
             self.setRect(0, 0, width, height)
@@ -60,6 +61,7 @@ class ShapeItem(DrawingItem):
         """
 
         self.update()
+        self._originally_movable = self.flags() & QtWidgets.QGraphicsItem.ItemIsMovable
         if event.pos().x() > (self.rect().right() - self._border):
             self.setFlag(QtWidgets.QGraphicsItem.ItemIsMovable, False)
             self._edge = "right"
@@ -75,7 +77,6 @@ class ShapeItem(DrawingItem):
         elif event.pos().y() > (self.rect().bottom() - self._border):
             self.setFlag(QtWidgets.QGraphicsItem.ItemIsMovable, False)
             self._edge = "bottom"
-
         QtWidgets.QGraphicsItem.mousePressEvent(self, event)
 
     def mouseReleaseEvent(self, event):
@@ -86,7 +87,7 @@ class ShapeItem(DrawingItem):
         """
 
         self.update()
-        self.setFlag(QtWidgets.QGraphicsItem.ItemIsMovable)
+        self.setFlag(QtWidgets.QGraphicsItem.ItemIsMovable, self._originally_movable)
         self._edge = None
         QtWidgets.QGraphicsItem.mouseReleaseEvent(self, event)
 
@@ -146,8 +147,8 @@ class ShapeItem(DrawingItem):
         :param event: QGraphicsSceneHoverEvent instance
         """
 
-        # objects on the background layer don't need cursors
-        if self.zValue() >= 0:
+        # locked objects don't need cursors
+        if not self.locked():
             if event.pos().x() > (self.rect().right() - self._border):
                 self._graphics_view.setCursor(QtCore.Qt.SizeHorCursor)
             elif event.pos().x() < (self.rect().left() + self._border):
@@ -166,13 +167,16 @@ class ShapeItem(DrawingItem):
         :param event: QGraphicsSceneHoverEvent instance
         """
 
-        # objects on the background layer don't need cursors
-        if self.zValue() >= 0:
+        # locked objects don't need cursors
+        if not self.locked():
             self._graphics_view.setCursor(QtCore.Qt.ArrowCursor)
 
+    def setWidthAndHeight(self, width, height):
+        self.setRect(0, 0, width, height)
+
     def fromSvg(self, svg):
         """
-        Import element informations from an SVG
+        Import element information from SVG
         """
         svg = ET.fromstring(svg)
         width = float(svg.get("width", self.rect().width()))

gns3/items/text_item.py

@@ -15,10 +15,6 @@
 # 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.
-"""
-
 import xml.etree.ElementTree as ET
 
 from ..qt import QtCore, QtWidgets, QtGui
@@ -44,8 +40,8 @@ class TextItem(QtWidgets.QGraphicsTextItem, DrawingItem):
         main_window = MainWindow.instance()
         view_settings = main_window.uiGraphicsView.settings()
         qt_font = QtGui.QFont()
-        qt_font.fromString(view_settings["default_label_font"])
-        self.setDefaultTextColor(QtGui.QColor(view_settings["default_label_color"]))
+        qt_font.fromString(view_settings["default_note_font"])
+        self.setDefaultTextColor(QtGui.QColor(view_settings["default_note_color"]))
         self.setFont(qt_font)
 
         if svg:
@@ -54,6 +50,10 @@ class TextItem(QtWidgets.QGraphicsTextItem, DrawingItem):
             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()
 
@@ -111,13 +111,6 @@ class TextItem(QtWidgets.QGraphicsTextItem, DrawingItem):
         super().paint(painter, option, widget)
         self.drawLayerInfo(painter)
 
-    def setZValue(self, value):
-        """
-        Sets Z value of the item
-        :param value: z layer
-        """
-        return DrawingItem.setZValue(self, value)
-
     def toSvg(self):
         """
         Return an SVG version of the text

gns3/link.py

@@ -19,12 +19,11 @@
 Manages and stores everything needed for a connection between 2 devices.
 """
 
-import os
 import re
 from .qt import sip
 import uuid
 
-from .qt import QtCore
+from .qt import QtCore, QtNetwork
 from .controller import Controller
 
 
@@ -79,6 +78,9 @@ class Link(QtCore.QObject):
         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
@@ -89,9 +91,7 @@ class Link(QtCore.QObject):
         self._creator = False
 
         self._nodes = []
-
-        self._source_node.addLink(self)
-        self._destination_node.addLink(self)
+        self._link_style = {}
 
         body = self._prepareParams()
         if self._link_id:
@@ -103,33 +103,45 @@ class Link(QtCore.QObject):
             Controller.instance().post("/projects/{project_id}/links".format(project_id=source_node.project().id()), self._linkCreatedCallback, body=body)
 
     def _parseResponse(self, result):
-        self._capturing = result.get("capturing", False)
 
-        # If the controller is remote the capture path should be rewrite to something local
+        self._capturing = result.get("capturing", False)
         if self._capturing:
-            if Controller.instance().isRemote():
-                if self._capture_file_path is None and result.get("capture_file_path", None) is not None:
+            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.QFile.WriteOnly)
                     self._capture_file.setAutoRemove(True)
                     self._capture_file_path = self._capture_file.fileName()
-                    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)
-            else:
-                self._capture_file_path = result["capture_file_path"]
+                else:
+                    self._capture_file = QtCore.QFile(self._capture_file_path)
+                    self._capture_file.open(QtCore.QFile.WriteOnly)
+
+                if self._network_manager is None:
+                    self._network_manager = QtNetwork.QNetworkAccessManager(self)
+                    self._network_manager.sslErrors.connect(Controller.instance().httpClient().handleSslError)
+
+                self._response_stream = Controller.instance().get(
+                    "/projects/{project_id}/links/{link_id}/capture/stream".format(project_id=self.project().id(), link_id=self._link_id),
+                    callback=None,
+                    show_progress=False,
+                    download_progress_callback=self._downloadPcapProgress,
+                    timeout=None,
+                    network_manager=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
 
         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)
@@ -212,6 +224,7 @@ class Link(QtCore.QObject):
                 }
             ],
             "filters": self._filters,
+            "link_style": self._link_style,
             "suspend": self._suspend
         }
         if self._source_port.label():
@@ -305,7 +318,7 @@ class Link(QtCore.QObject):
             self._source_port.name(),
             self._destination_node.name(),
             self._destination_port.name())
-        return re.sub("[^0-9A-Za-z_-]", "", capture_file_name)
+        return re.sub(r"[^0-9A-Za-z_-]", "", capture_file_name)
 
     def deleteLink(self, skip_controller=False):
         """
@@ -343,67 +356,85 @@ class Link(QtCore.QObject):
         # let the GUI know about this link has been deleted
         self.delete_link_signal.emit(self._id)
 
+    def resetLink(self):
+        """
+        Resets this link.
+        """
+
+        log.debug("reset link from {} {} to {} {}".format(self._source_node.name(),
+                                                          self._source_port.name(),
+                                                          self._destination_node.name(),
+                                                          self._destination_port.name()))
+
+        Controller.instance().post("/projects/{project_id}/links/{link_id}/reset".format(project_id=self.project().id(),
+                                                                                         link_id=self._link_id),
+                                                                                         self._linkResetCallback)
+
+    def _linkResetCallback(self, result, error=False, **kwargs):
+        """
+        Called after the link is reset.
+        """
+
+        if error:
+            log.error("Error while resetting link: {}".format(result["message"]))
+            return
+
     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)
+        Controller.instance().post("/projects/{project_id}/links/{link_id}/capture/start".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(result["message"]))
+            log.error("Error while starting capture on link {}: {}".format(self._link_id, result["message"]))
             return
-        self._parseResponse(result)
 
     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():
+
+        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("Can't remove file {}: {}".format(self._capture_file_path, e))
+            # 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)
+        Controller.instance().post("/projects/{project_id}/links/{link_id}/capture/stop".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(result["message"]))
+            log.error("Error while stopping capture on link {}: {}".format(self._link_id, result["message"]))
             return
-        self._parseResponse(result)
+        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)
+        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):
         """
@@ -471,3 +502,9 @@ class Link(QtCore.QObject):
         :params filters: List of filters
         """
         self._filters = filters
+
+    def setLinkStyle(self, link_style):
+        """
+        :params _link_style: Set link style attributes
+        """
+        self._link_style = link_style

gns3/linux/applications/gns3.desktop

@@ -0,0 +1,11 @@
+[Desktop Entry]
+Version=1.0
+Type=Application
+Terminal=false
+Exec=gns3 %f
+Name=GNS3
+Comment=GNS3 Graphical Network Simulator
+Icon=gns3
+Categories=Education;Network;
+MimeType=application/x-gns3;application/x-gns3appliance;application/x-gns3project;
+Keywords=simulator;network;netsim;

gns3/linux/gns3-gui.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<mime-info xmlns="http://www.freedesktop.org/standards/shared-mime-info">
+    <mime-type type="application/x-gns3">
+        <comment>GNS3 Project File</comment>
+	    <comment xml:lang="en">GNS3 Project File</comment>
+    	<glob pattern="*.gns3"/>
+    </mime-type>
+    <mime-type type="application/x-gns3project">
+        <comment>GNS3 Project File</comment>
+	    <comment xml:lang="en">GNS3 Portable Project File</comment>
+    	<glob pattern="*.gns3project"/>
+    </mime-type>
+    <mime-type type="application/x-gns3project">
+        <comment>GNS3 Project File</comment>
+	    <comment xml:lang="en">GNS3 Portable Project File</comment>
+    	<glob pattern="*.gns3p"/>
+    </mime-type>
+    <mime-type type="application/x-gns3appliance">
+        <comment>GNS3 Appliance File</comment>
+	    <comment xml:lang="en">GNS3 Appliance File</comment>
+    	<glob pattern="*.gns3appliance"/>
+    </mime-type>
+    <mime-type type="application/x-gns3appliance">
+        <comment>GNS3 Appliance File</comment>
+	    <comment xml:lang="en">GNS3 Appliance File</comment>
+    	<glob pattern="*.gns3a"/>
+    </mime-type>
+</mime-info>

gns3/linux/icons/hicolor/scalable/mimetypes/application-x-gns3project.svg

@@ -0,0 +1,95 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Generator: Adobe Illustrator 18.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   version="1.1"
+   id="Layer_1"
+   x="0px"
+   y="0px"
+   viewBox="0 0 256 256"
+   enable-background="new 0 0 792 612"
+   xml:space="preserve"
+   inkscape:version="0.48.4 r9939"
+   width="100%"
+   height="100%"
+   sodipodi:docname="gns3_project_base_icon.svg"
+   inkscape:export-filename="/home/grossmj/Downloads/Logos/gns3_project.png"
+   inkscape:export-xdpi="90"
+   inkscape:export-ydpi="90"><metadata
+     id="metadata30"><rdf:RDF><cc:Work
+         rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" /><dc:title></dc:title></cc:Work></rdf:RDF></metadata><defs
+     id="defs28" /><sodipodi:namedview
+     pagecolor="#000000"
+     bordercolor="#666666"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="688"
+     inkscape:window-height="508"
+     id="namedview26"
+     showgrid="false"
+     inkscape:zoom="2.8284271"
+     inkscape:cx="99.209744"
+     inkscape:cy="115.40526"
+     inkscape:window-x="692"
+     inkscape:window-y="203"
+     inkscape:window-maximized="0"
+     inkscape:current-layer="g3"
+     fit-margin-top="0"
+     fit-margin-left="0"
+     fit-margin-right="0"
+     fit-margin-bottom="0" /><g
+     id="g3"
+     transform="translate(-19.09309,-355.40651)"><linearGradient
+       id="SVGID_1_"
+       gradientUnits="userSpaceOnUse"
+       x1="404.2251"
+       y1="365.32321"
+       x2="384.2139"
+       y2="136.595"
+       gradientTransform="matrix(0.9154681,0,0,0.8343604,-205.93817,243.15241)"><stop
+         offset="0"
+         style="stop-color:#00A5CE"
+         id="stop6" /><stop
+         offset="0.1989"
+         style="stop-color:#1295CB"
+         id="stop8" /><stop
+         offset="0.5994"
+         style="stop-color:#426BC5"
+         id="stop10" /><stop
+         offset="1"
+         style="stop-color:#783CBD"
+         id="stop12" /></linearGradient><path
+       d="m 171.60071,405.01864 c 0,4.83934 -4.30236,8.76063 -9.61217,8.76063 -5.30966,0 -9.61254,-3.92129 -9.61254,-8.76063 0,-4.83945 4.30288,-8.76118 9.61254,-8.76118 5.30981,0 9.61217,3.92173 9.61217,8.76118 z M 66.413524,449.07279 c -5.767437,28.78523 2.105621,49.56075 14.372861,64.41269 21.879695,28.11798 54.012515,33.04057 54.012515,33.04057 37.53432,6.50778 66.09685,-5.33982 83.21603,-20.02463 21.51357,-18.60601 20.7815,-37.04552 20.87311,-37.29575 0.18299,-8.59424 -2.92957,-14.7682 -8.42235,-19.02378 -9.24633,-7.09206 -20.86017,2.69341 -20.86017,2.69341 -19.49927,4.17192 -15.94169,13.32637 -15.94169,13.32637 1.09845,4.83918 3.84457,8.00978 6.95741,9.84533 5.9504,3.33747 12.26728,2.67002 12.26728,2.67002 9.3378,-1.0009 12.08427,-9.0109 11.53485,-13.01608 -0.91555,-6.34088 -7.23234,-7.50924 -7.23234,-7.50924 -2.38005,-0.41709 -4.21098,-0.0833 -5.58438,0.58407 -2.01358,0.75135 -2.83796,2.00243 -2.83796,2.00243 -1.46454,2.25284 -0.54914,3.50469 0.36639,4.00532 0.54947,0.33369 1.19036,0.33369 1.19036,0.33369 0.73207,0 1.18967,-0.16678 1.73912,-0.41707 1.28185,-0.6675 2.2885,-1.7525 4.21141,-1.085 2.83793,1.00135 2.10546,3.7549 2.10546,3.7549 -0.641,3.00358 -2.5634,4.42215 -4.66897,4.9226 -2.83795,0.66751 -5.76742,-0.16678 -5.76742,-0.16678 -10.07028,-3.75491 -5.58438,-12.93261 -5.58438,-12.93261 3.11245,-5.75734 10.07038,-6.42485 10.07038,-6.42485 10.89377,-1.58499 18.12615,5.08962 16.93565,16.35342 -1.37299,14.0176 -13.18224,23.27863 -25.81601,29.11962 -47.32956,22.19367 -82.66676,-5.92441 -82.66676,-5.92441 -13.18276,-11.43056 -10.07016,-23.52883 -8.60541,-27.3666 0.54929,-1.41865 2.01406,-1.6691 2.74639,-1.6691 10.80253,-0.83407 19.774,17.35498 20.68947,19.85809 1.92249,4.17184 4.94343,6.50765 7.78138,8.00972 6.40841,3.25405 13.18313,1.66883 13.18313,1.66883 9.33745,-2.9202 6.1335,-9.84533 6.1335,-9.84533 -1.09842,-2.75341 -2.74644,-3.50477 -4.02786,-3.42093 -1.19054,0 -2.10564,0.83442 -2.10564,0.83442 -0.45776,0.50034 -1.00731,0.83393 -1.46489,1.25125 -5.95071,4.58892 -8.8803,-0.25044 -8.8803,-0.25044 -2.10546,-3.08697 1.09901,-4.75583 1.09901,-4.75583 0.64083,-0.33355 1.28141,-0.50061 1.73895,-0.66748 2.38042,-0.66714 2.01441,-2.50311 2.01441,-2.50311 -0.36609,-3.42046 -4.57745,-2.00244 -4.57745,-2.00244 -4.1195,1.3353 -5.40139,4.42214 -5.76771,5.75738 -0.0915,0.41727 -0.1831,0.75095 -0.8236,0.83435 -1.18996,0.16676 -1.18996,-1.75225 -1.18996,-1.75225 -0.36654,-13.68349 -4.4859,-19.77428 -6.40854,-21.94348 -0.54936,-0.66796 -1.46475,-1.08497 -1.73923,-1.25176 -4.30289,-1.7521 -9.06329,-5.17302 -9.06329,-5.17302 -9.06314,-5.92391 -5.4928,-11.26375 -5.4928,-11.26375 5.40125,-12.34883 9.79555,-16.60411 9.79555,-16.60411 3.66173,-3.17061 7.50696,-0.33364 7.50696,-0.33364 -2.83792,3.17075 -5.03524,6.25803 -5.03524,6.25803 -6.49982,9.42787 -7.59841,13.26624 -7.59841,13.26624 -0.0915,0.33355 -0.0915,0.91765 0.45776,1.58531 6.68291,10.42945 24.7176,12.01453 24.80912,12.01453 4.94374,0.66741 8.97144,0.0834 8.97144,0.0834 2.38032,-0.41707 2.74642,1.00145 2.74642,1.00145 0.27482,0.83443 1.28199,3.17072 1.28199,3.17072 1.73928,3.33708 4.3939,1.5849 4.3939,1.5849 1.00743,-0.66745 1.465,-1.5849 1.465,-2.33588 0,-0.75128 -0.45757,-1.25175 -0.45757,-1.25175 -1.19053,-1.58542 -1.55653,-3.0869 -1.55653,-3.0869 -0.54909,-1.83594 1.73957,-2.58648 1.73957,-2.58648 4.48544,-1.83599 6.95727,1.66826 6.95727,1.66826 2.38047,2.5865 7.14092,-0.66745 7.14092,-0.66745 3.8449,-2.66992 -4.0976,0.19062 -4.0976,0.19062 -9.88688,-8.26038 -16.56361,-1.34696 -16.56361,-1.34696 -0.64104,0.7511 -3.04976,-2.76495 -3.04976,-2.76495 -9.61199,0.25048 -18.76672,-6.17438 -18.76672,-6.50818 3.66187,-5.5901 10.71075,-15.35234 10.71075,-15.35234 l 37.25985,13.09964 c 1.46442,0.41703 3.02095,0.0833 3.02095,0.0833 l 58.04043,-10.67989 c 1.28195,-0.16687 1.09896,-1.58503 1.09896,-1.58503 0,-1.16837 -0.0919,-1.33515 -1.19046,-1.50194 -1.18994,-0.16678 -56.48449,-4.08849 -56.48449,-4.08849 -3.02097,-0.16681 -3.02097,-3.92122 0.0915,-4.17141 l 40.64728,-3.08733 c 0.91552,-0.0834 1.09848,-0.91783 1.09848,-0.91783 1.09844,-4.92279 0.73198,-11.34711 0.73198,-11.34711 11.80979,-12.01521 6.1339,-23.86288 6.1339,-23.86288 -7.23198,-16.35348 -23.1616,-16.60396 -23.1616,-16.60396 -26.18203,-26.36565 -60.60355,-23.27867 -60.60355,-23.27867 -1.55672,0 -1.6483,1.1683 -1.6483,1.1683 l -3.93608,22.69445 c -0.18325,1.25177 -0.91581,1.58533 -0.91581,1.58533 l -5.21788,3.75447 c -0.6411,0.58421 -0.82414,0.58421 -1.73956,0.58421 -0.82389,0.0835 -3.38706,0.41742 -3.38706,0.41742 -61.519582,11.93091 -70.399667,62.15974 -70.399667,62.15974 z M 232.66269,395.33968 c 2.47189,7.17584 -4.30298,9.42866 -4.30298,9.42866 -1.28144,-5.59034 -5.76742,-13.4333 -5.76742,-13.4333 7.59878,-2.16932 10.0704,4.00464 10.0704,4.00464 z m -38.08373,12.7658 c 0,13.18286 -11.71793,23.94621 -26.27368,23.94621 -14.46437,0 -26.27391,-10.67996 -26.27391,-23.94621 0,-13.26611 11.80954,-23.94585 26.27391,-23.94585 14.55575,0 26.27368,10.76313 26.27368,23.94585 z"
+       id="path14"
+       inkscape:connector-curvature="0"
+       style="fill:url(#SVGID_1_);stroke:#000000;stroke-width:1.59908056;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       sodipodi:nodetypes="ssssscccccccccccccccccccccccccccccccccccccccccccccccccccccccccscccccccccccccccccccccccccccccccccccsssss" /><path
+       style="fill:#ffffff;fill-opacity:1;stroke:#000000;stroke-width:1.53344321;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       d="m 158.75467,430.66421 c -20.07367,-7.21051 -22.89938,-32.31848 -4.80964,-42.73635 5.48181,-3.15698 10.67085,-4.37809 16.54241,-3.89283 9.69836,0.8015 17.57306,5.9338 21.90388,14.2758 2.15749,4.15572 2.35397,5.15328 2.09049,10.61352 -0.34596,7.1686 -2.32163,11.43951 -7.45042,16.1059 -5.29156,4.81452 -10.10597,6.6958 -17.7209,6.92464 -4.93337,0.14827 -7.384,-0.1514 -10.55582,-1.29068 z m 8.60473,-19.04379 c 4.68093,-3.03776 4.59848,-10.37728 -0.15058,-13.40894 -4.87998,-3.11524 -12.93893,-0.19374 -14.0254,5.08442 -1.51639,7.36707 7.49622,12.65953 14.17598,8.32452 z"
+       id="path3756"
+       inkscape:connector-curvature="0" /><path
+       style="fill:#ffffff;fill-opacity:1;stroke:#000000;stroke-width:1.53344321;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       d="m 227.52716,403.78857 c -0.005,-0.70451 -1.22789,-3.82375 -2.7167,-6.93163 -2.55419,-5.33189 -2.6206,-5.67568 -1.17683,-6.09329 5.73392,-1.65864 11.08127,3.87024 9.37974,9.69827 -0.98678,3.37997 -5.465,6.09542 -5.48621,3.32665 z"
+       id="path3758"
+       inkscape:connector-curvature="0" /><path
+       sodipodi:nodetypes="sccccccccccscssccsscccccccsss"
+       style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:none"
+       inkscape:connector-curvature="0"
+       id="path3810"
+       d="m 239.93926,461.59913 0.0895,0.12221 -1.17469,-1.46733 -32.98343,9.00545 -37.23862,-8.13752 -55.68743,19.71173 -26.020537,-23.43049 -22.596889,16.06861 -11.889522,-13.06537 -0.909404,1.46024 -0.899284,1.4798 c -10.753621,17.54929 -16.66218,36.40349 -16.66218,54.40796 0,27.619 11.056869,51.53032 32.647508,68.48515 20.408405,16.0284 49.491298,25.55892 80.597778,25.55892 31.10647,0 59.83583,-9.88212 80.24671,-25.91052 21.59065,-16.95484 32.29143,-40.51455 32.29143,-68.13355 -0.002,-19.76102 -7.4557,-37.40288 -19.8109,-56.15529 z m -93.0808,146.64361 c -64.382901,0 -109.352655,-37.21035 -109.352655,-90.48655 0,-17.02801 5.398302,-34.83435 15.234948,-51.5232 l 9.904862,13.47926 23.843928,-16.75492 25.086777,22.57192 56.84998,-20.39383 37.73928,8.09108 30.77268,-8.56604 c 12.01921,18.34365 19.27279,33.79352 19.27279,53.09573 0,53.2762 -44.96719,90.48655 -109.35259,90.48655 z" /><path
+       style="fill:#fefefa;fill-opacity:1;stroke:#ffffff;stroke-width:1.04580986000000009;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
+       d="M 138.44788,607.85596 C 113.73945,606.22444 93.962212,600.20959 76.995281,589.1664 55.352378,575.07977 42.490317,555.32103 38.520707,530.06164 c -0.759205,-4.83094 -0.874973,-17.42518 -0.205365,-22.34039 1.791597,-13.15109 5.868285,-25.3134 12.758033,-38.06201 0.84206,-1.55812 1.659698,-2.75565 1.816969,-2.66115 0.157281,0.0945 2.381859,3.03194 4.9435,6.5277 2.561642,3.49575 4.723755,6.35591 4.80468,6.35591 0.0809,0 5.326847,-3.64298 11.657596,-8.0955 6.330738,-4.45253 11.699908,-8.16513 11.931484,-8.25022 0.231577,-0.085 4.398802,3.42528 9.260505,7.80084 4.861701,4.37556 10.457641,9.41045 12.435431,11.18865 l 3.59596,3.23309 28.31322,-10.1561 c 15.57226,-5.58585 28.50887,-10.1561 28.74803,-10.1561 0.23916,0 8.7836,1.79241 18.98766,3.9831 l 18.55285,3.98308 14.95072,-4.15493 c 8.2229,-2.28522 15.17245,-4.15493 15.44345,-4.15493 0.27101,0 1.79664,2.10211 3.39032,4.67137 11.40625,18.38862 15.96668,32.0966 15.97665,48.02357 0.006,9.17148 -1.01587,16.56703 -3.40156,24.6239 -9.62567,32.50771 -38.51348,55.82167 -78.32153,63.20957 -10.50247,1.94913 -25.62193,2.8911 -35.71143,2.22487 z"
+       id="path3821"
+       inkscape:connector-curvature="0" /></g></svg>

gns3/local_config.py

@@ -23,10 +23,9 @@ import copy
 
 import psutil
 
-from .qt import QtCore, QtWidgets, qslot
-from .version import __version__
+from .qt import QtCore, QtWidgets
+from .version import __version__, __version_info__
 from .utils import parse_version
-from .controller import Controller
 
 import logging
 log = logging.getLogger(__name__)
@@ -39,38 +38,17 @@ class LocalConfig(QtCore.QObject):
     """
 
     config_changed_signal = QtCore.Signal()
-    # When this signal is emit the config is saved on controller
-    save_on_controller_signal = QtCore.Signal()
 
     def __init__(self, config_file=None):
         """
-        :param config_file: Path to the config file (override all other config, usefull for tests)
+        :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
-        # Security to avoid pushing to the controller settings before
-        # we get the original settings from controller
-        self._settings_retrieved_from_controller = False
         self._migrateOldConfigPath()
         self._resetLoadConfig()
-        self._monitoring_changes = False
-        Controller.instance().connected_signal.connect(self.refreshConfigFromController)
-        self.save_on_controller_signal.connect(self._saveOnController)
-
-    def _monitorChanges(self):
-        """
-        Poll the remote server waiting for settings update
-        """
-        if self._monitoring_changes:
-            return
-        self._monitoring_changes = True
-        self._timer = QtCore.QTimer()
-        self._timer.setInterval(5000)
-        self._refreshingSettings = False
-        self._timer.timeout.connect(self.refreshConfigFromController)
-        self._timer.start()
 
     def _resetLoadConfig(self):
         """
@@ -109,8 +87,25 @@ 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)
-                with open(self._config_file, "w", encoding="utf-8") as f:
-                    json.dump({"version": __version__, "type": "settings"}, f)
+
+                if sys.platform.startswith("win"):
+                    old_config_path = os.path.join(os.path.expandvars("%APPDATA%"), "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("Controller", CONTROLLER_SETTINGS)
+                    # settings["path"] = ""
+                    # settings["ubridge_path"] = ""
+                    # LocalServerConfig.instance().saveSettings("Controller", settings)
+                else:
+                    # create a new config
+                    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))
 
@@ -136,47 +131,18 @@ class LocalConfig(QtCore.QObject):
             self._config_file = None
             self._resetLoadConfig()
 
-    @qslot
-    def refreshConfigFromController(self):
-        """
-        Refresh the configuration from the controller
-        """
-        controller = Controller.instance()
-        if controller.connected():
-            self._refreshingSettings = True
-            controller.get("/settings", self._getSettingsCallback, showProgress=False)
-        self._monitorChanges()
-
-    def _getSettingsCallback(self, result, error=False, **kwargs):
-        self._refreshingSettings = False
-        if error:
-            log.debug("Can't get settings from controller")
-            return
-        if result == {} and self._settings != {}:
-            self._settings_retrieved_from_controller = True
-            self.save_on_controller_signal.emit()
-            return
-
-        # The server return an uuid to keep track of settings version
-        if self._settings.get("modification_uuid") != result.get("modification_uuid"):
-            self._settings.update(result)
-            # Update already loaded section
-            for section in self._settings.keys():
-                if isinstance(self._settings[section], dict):
-                    self.loadSectionSettings(section, self._settings[section])
-            self.config_changed_signal.emit()
-        self._settings_retrieved_from_controller = True
-
     def configDirectory(self):
         """
         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")
+            path = os.path.join(appdata, "GNS3", version)
         else:
             home = os.path.expanduser("~")
-            path = os.path.join(home, ".config", "GNS3")
+            path = os.path.join(home, ".config", "GNS3", version)
 
         if self._profile is not None:
             path = os.path.join(path, "profiles", self._profile)
@@ -198,8 +164,9 @@ 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")
+            new_path = os.path.join(os.path.expanduser("~"), ".config", "GNS3", version)
             if os.path.exists(old_path) and not os.path.exists(new_path):
                 try:
                     shutil.copytree(old_path, new_path)
@@ -208,7 +175,7 @@ class LocalConfig(QtCore.QObject):
 
     def _migrateOldConfig(self):
         """
-        Migrate pre 1.4 config
+        Migrate config from a previous version.
         """
 
         # Display an error if settings come from a more recent version of GNS3
@@ -217,7 +184,7 @@ 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 = "Your settings are for version {} of GNS3. You cannot use a previous version of GNS3 without risking losing data. If you want to reset delete the settings in {}".format(self._settings["version"], self.configDirectory())
+                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)
                 # Exit immediately not clean but we want to avoid any side effect that could corrupt the file
                 QtCore.QTimer.singleShot(0, app.quit)
@@ -226,21 +193,21 @@ class LocalConfig(QtCore.QObject):
 
         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"
 
-            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
@@ -253,7 +220,7 @@ class LocalConfig(QtCore.QObject):
                     if self._settings["MainWindow"].get("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
+         # 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
@@ -264,7 +231,7 @@ class LocalConfig(QtCore.QObject):
                         vms.append(vm)
                 self._settings["Qemu"]["vms"] = vms
 
-        # Starting with 2.0.0dev5 IOU licence is stored in the settings
+         # 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:
@@ -312,25 +279,6 @@ class LocalConfig(QtCore.QObject):
             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))
-        self.save_on_controller_signal.emit()
-
-    @qslot
-    def _saveOnController(self, *args):
-        """
-        Save some settings on controller for the transition from
-        GUI to a central controller. Will be removed later
-        """
-        if Controller.instance().connected() and self._settings_retrieved_from_controller:
-            # We save only non user specific sections
-            section_to_save_on_controller = ["Builtin", "Docker", "IOU", "Qemu", "VMware", "VPCS", "TraceNG", "VirtualBox", "GraphicsView", "Dynamips"]
-            controller_settings = {}
-            for key, val in self._settings.items():
-                if key in section_to_save_on_controller:
-                    controller_settings[key] = val
-                # We want only the VM settings on the server
-                elif key == "Server":
-                    controller_settings["Server"]["vm"] = self._settings["Server"]["vm"]
-            Controller.instance().post("/settings", None, body=controller_settings)
 
     def checkConfigChanged(self):
 
@@ -466,28 +414,13 @@ class LocalConfig(QtCore.QObject):
         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)
+        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
@@ -495,6 +428,22 @@ class LocalConfig(QtCore.QObject):
         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():
         """
@@ -518,12 +467,12 @@ class LocalConfig(QtCore.QObject):
 
         if os.path.exists(pid_path):
             try:
-                with open(pid_path) as f:
+                with open(pid_path, encoding="utf-8") as f:
                     pid = int(f.read())
                     if pid != my_pid:
                         try:
                             process = psutil.Process(pid=pid)
-                            ps_name = process.name()
+                            ps_name = process.name().lower()
                         except (OSError, psutil.NoSuchProcess, psutil.AccessDenied):
                             pass
                         else:
@@ -533,9 +482,17 @@ class LocalConfig(QtCore.QObject):
                                     return False
                     else:
                         return True
-            except (OSError, ValueError) as e:
+            except OSError 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,6 +1,6 @@
 #!/usr/bin/env python
 #
-# Copyright (C) 2016 GNS3 Technologies Inc.
+# Copyright (C) 2021 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
@@ -22,8 +22,6 @@ import stat
 import shlex
 import socket
 import shutil
-import random
-import string
 import struct
 import psutil
 import signal
@@ -31,14 +29,12 @@ import subprocess
 
 
 from gns3.qt import QtWidgets, QtCore, qslot
-from gns3.settings import LOCAL_SERVER_SETTINGS
+from gns3.settings import DEFAULT_CONTROLLER_HOST
 from gns3.local_config import LocalConfig
-from gns3.local_server_config import LocalServerConfig
+from gns3.http_client import HTTPClient
 from gns3.utils.wait_for_connection_worker import WaitForConnectionWorker
 from gns3.utils.progress_dialog import ProgressDialog
-from gns3.utils.http import getSynchronous
 from gns3.utils.sudo import sudo
-from gns3.http_client import HTTPClient
 from gns3.controller import Controller
 
 
@@ -95,13 +91,6 @@ class LocalServer(QtCore.QObject):
         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)
@@ -123,26 +112,6 @@ class LocalServer(QtCore.QObject):
             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))
-
-        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.
@@ -193,18 +162,16 @@ class LocalServer(QtCore.QObject):
                         QtWidgets.QMessageBox.Yes,
                         QtWidgets.QMessageBox.No)
                     if proceed == QtWidgets.QMessageBox.Yes:
-                        sudo(["chown", "root:admin", path], ["chmod", "4750", path])
+                        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.
@@ -212,14 +179,9 @@ class LocalServer(QtCore.QObject):
         :returns: local server settings (dict)
         """
 
-        settings = LocalServerConfig.instance().loadSettings("Server", LOCAL_SERVER_SETTINGS)
+        settings = Controller.instance().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:
@@ -246,16 +208,19 @@ class LocalServer(QtCore.QObject):
         """
         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_CONTROLLER_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)
+        Controller.instance().setSettings(self._settings)
 
         # Settings have changed we need to restart the server
-        if old_settings != self._settings:
+        if not Controller.instance().connected() or 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')
@@ -267,16 +232,12 @@ class LocalServer(QtCore.QObject):
                 if need_restart:
                     self.stopLocalServer(wait=True)
 
-                self.localServerAutoStartIfRequire()
+                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)
+                if Controller.instance().isRemote() and not Controller.instance().connected():
+                    Controller.instance().connect()
 
     def shouldLocalServerAutoStart(self):
         """
@@ -313,34 +274,29 @@ class LocalServer(QtCore.QObject):
             # Permission issue, or process no longer exists, or file is empty
             return
 
-    def localServerAutoStartIfRequire(self):
+    def localServerAutoStartIfRequired(self):
         """
-        Try to start the embed gns3 server.
+        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:
+        local_server_already_running = self.isLocalServerRunning()
+        if local_server_already_running 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)
+            Controller.instance().connect()
             return True
 
-        if self.isLocalServerRunning():
+        if local_server_already_running:
             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 local_server_already_running:
             if not self.initLocalServer():
                 QtWidgets.QMessageBox.critical(self.parent(), "Local server", "Could not start the local server process: {}".format(self._settings["path"]))
                 return False
@@ -351,16 +307,14 @@ class LocalServer(QtCore.QObject):
         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),
+                                             "Local controller",
+                                             "Starting local controller {} 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)
-
+        Controller.instance().connect()
         return True
 
     def initLocalServer(self):
@@ -369,11 +323,6 @@ class LocalServer(QtCore.QObject):
         """
 
         self._checkUbridgePermissions()
-
-        if sys.platform.startswith('win'):
-            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.")
-
         self._port = self._settings["port"]
         # check the local server path
         local_server_path = self.localServerPath()
@@ -465,18 +414,22 @@ class LocalServer(QtCore.QObject):
                 except FileNotFoundError:
                     pass
                 except OSError as e:
-                    log.warn("could not delete server log file {}: {}".format(logpath, e))
-            command += ' --log="{}" --pid="{}"'.format(logpath, self._pid_path())
+                    log.warning("could not delete server log file {}: {}".format(logpath, e))
+            command += ' --logfile="{}" --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)
+                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)
+                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
@@ -515,21 +468,8 @@ class LocalServer(QtCore.QObject):
         :returns: boolean
         """
 
-        status, json_data = getSynchronous(self._settings["protocol"], self._settings["host"], self._port, "version",
-                                           timeout=2, user=self._settings["user"], password=self._settings["password"])
-
-        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
+        http_client = HTTPClient(self._settings)
+        return http_client.checkServerRunning()
 
     def stopLocalServer(self, wait=False):
         """
@@ -540,13 +480,14 @@ class LocalServer(QtCore.QObject):
 
         if self.localServerProcessIsRunning():
             self._stopping = True
-            log.debug("Stopping local server (PID={})".format(self._local_server_process.pid))
+            log.debug("Stopping local controller (PID={})".format(self._local_server_process.pid))
             # local server is running, let's stop it
-            if self._http_client:
-                self._http_client.shutdown()
+            http_client = Controller.instance().httpClient()
+            if http_client:
+                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 = ProgressDialog(worker, "Local server", "Waiting for the local controller to stop...", None, busy=True, parent=self.parent())
                 progress_dialog.show()
                 progress_dialog.exec_()
                 if self._local_server_process.returncode is None:
@@ -569,8 +510,8 @@ class LocalServer(QtCore.QObject):
             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?",
+                                                     "Local controller",
+                                                     "The local controller cannot be stopped, would you like to kill it?",
                                                      QtWidgets.QMessageBox.Yes,
                                                      QtWidgets.QMessageBox.No)
 

gns3/local_server_config.py

@@ -1,151 +0,0 @@
-# -*- 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/>.
-
-import os
-import sys
-import configparser
-
-
-import logging
-log = logging.getLogger(__name__)
-
-
-class LocalServerConfig:
-
-    """
-    Local server configuration.
-    """
-
-    def __init__(self, config_file=None):
-
-        appname = "GNS3"
-
-        self._config = configparser.RawConfigParser()
-
-        if config_file:
-            self._config_file = config_file
-        else:
-            if sys.platform.startswith("win"):
-                filename = "gns3_server.ini"
-            else:
-                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)
-
-        try:
-            # create the config file if it doesn't exist
-            open(self._config_file, "a").close()
-        except OSError as e:
-            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.
-        """
-
-        try:
-            self._config.read(self._config_file, encoding="utf-8")
-        except (OSError, configparser.Error, UnicodeEncodeError, UnicodeDecodeError) as e:
-            log.error("Could not read the local server configuration {}: {}".format(self._config_file, e))
-
-    def writeConfig(self):
-        """
-        Write the configuration file.
-        """
-
-        try:
-            log.debug("Write configuration file %s", self._config_file)
-            with open(self._config_file, "w", encoding="utf-8") as fp:
-                self._config.write(fp)
-        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):
-        """
-        Get all the settings from a given section.
-
-        :param section: section name
-        :param default_settings: setting names and default values (dict)
-
-        :returns: settings (dict)
-        """
-
-        if section not in self._config:
-            self._config[section] = {}
-
-        settings = {}
-        for name, default in default_settings.items():
-            if isinstance(default, bool):
-                settings[name] = self._config[section].getboolean(name, default)
-            elif isinstance(default, int):
-                settings[name] = self._config[section].getint(name, default)
-            elif isinstance(default, 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)
-        return settings
-
-    def saveSettings(self, section, settings):
-        """
-        Save all the settings in a given section.
-
-        :param section: section name
-        :param settings: settings to save (dict)
-        """
-
-        changed = False
-        if section not in self._config:
-            self._config[section] = {}
-            changed = True
-
-        for name, value in settings.items():
-            if name not in self._config[section] or self._config[section][name] != str(value):
-                self._config[section][name] = str(value)
-                changed = True
-
-        if changed:
-            self.writeConfig()
-
-    @staticmethod
-    def instance():
-        """
-        Singleton to return only on instance of LocalServerConfig.
-
-        :returns: instance of Config
-        """
-
-        if not hasattr(LocalServerConfig, "_instance"):
-            LocalServerConfig._instance = LocalServerConfig()
-        return LocalServerConfig._instance

gns3/logger.py

@@ -121,7 +121,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.warn("could not log to {}: {}".format(logfile, e))
+        log.warning("could not log to {}: {}".format(logfile, e))
 
     log.info('Log level: {}'.format(logging.getLevelName(level)))
 

gns3/main.py

@@ -30,16 +30,6 @@ 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
@@ -59,13 +49,14 @@ 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.utils.install_mime_types import install_mime_types
 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():
     """
@@ -90,13 +81,13 @@ def locale_check():
         log.error("could not determine the current locale: {}".format(e))
     if not language and not encoding:
         try:
-            log.warn("could not find a default locale, switching to C.UTF-8...")
+            log.warning("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.warn("your locale {}.{} encoding is not UTF-8, switching to the UTF-8 version...".format(language, encoding))
+        log.warning("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:
@@ -118,6 +109,9 @@ def main():
     # 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="?")
@@ -126,27 +120,36 @@ def main():
     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)")
+    parser.add_argument("--install-mime-types", help="Install mime types (Linux only)", action="store_true", default=False)
     options = parser.parse_args()
     exception_file_path = "exceptions.log"
 
+    if options.install_mime_types:
+        install_mime_types()
+        return
+
     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,
-                os.path.normpath(os.path.join(frozen_dir, '..', 'Resources'))
-            ]
+            frozen_dirs = [frozen_dir]
         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.environ["PATH"] = os.pathsep.join(frozen_dirs) + os.pathsep + os.environ.get("PATH", "")
@@ -154,6 +157,7 @@ def main():
         if options.project:
             os.chdir(frozen_dir)
 
+
     def exceptionHook(exception, value, tb):
 
         if exception == KeyboardInterrupt:
@@ -185,9 +189,9 @@ def main():
     # catch exceptions to write them in a file
     sys.excepthook = exceptionHook
 
-    # we only support Python 3 version >= 3.4
-    if sys.version_info < (3, 4):
-        raise SystemExit("Python 3.4 or higher is required")
+    # we only support Python 3 version >= 3.9
+    if sys.version_info < (3, 9):
+        raise SystemExit("Python 3.9 or higher is required")
 
     if parse_version(QtCore.QT_VERSION_STR) < parse_version("5.5.0"):
         raise SystemExit("Requirement is PyQt5 version 5.5.0 or higher, got version {}".format(QtCore.QT_VERSION_STR))
@@ -220,10 +224,17 @@ def main():
         if not options.debug:
             try:
                 # hide the console
+                # win32console.AllocConsole()
                 console_window = win32console.GetConsoleWindow()
-                win32gui.ShowWindow(console_window, win32con.SW_HIDE)
+                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")
             except win32console.error as e:
-                print("warning: could not allocate console: {}".format(e))
+                log.warning("Could not allocate console: {}".format(e))
 
     local_config = LocalConfig.instance()
 
@@ -258,8 +269,8 @@ def main():
     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.info("Application started with {}".format(" ".join(sys.argv)))
+    log.debug("PATH={}".format(os.environ["PATH"]))
 
     # 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)

gns3/main_window.py

@@ -39,21 +39,23 @@ from .dialogs.snapshots_dialog import SnapshotsDialog
 from .dialogs.export_debug_dialog import ExportDebugDialog
 from .dialogs.doctor_dialog import DoctorDialog
 from .dialogs.edit_project_dialog import EditProjectDialog
+from .dialogs.image_dialog import ImageDialog
 from .dialogs.setup_wizard import SetupWizard
 from .settings import GENERAL_SETTINGS
 from .items.node_item import NodeItem
-from .items.link_item import LinkItem
+from .items.link_item import LinkItem, SvgIconItem
 from .items.shape_item import ShapeItem
+from .items.label_item import LabelItem
 from .topology import Topology
 from .http_client import HTTPClient
 from .progress import Progress
 from .update_manager import UpdateManager
-from .utils.analytics import AnalyticsClient
 from .dialogs.appliance_wizard import ApplianceWizard
-from .dialogs.new_appliance_dialog import NewApplianceDialog
+from .dialogs.new_template_wizard import NewTemplateWizard
 from .dialogs.notif_dialog import NotifDialog, NotifDialogHandler
 from .status_bar import StatusBarHandler
 from .registry.appliance import ApplianceError
+from .template_manager import TemplateManager
 from .appliance_manager import ApplianceManager
 
 log = logging.getLogger(__name__)
@@ -82,6 +84,42 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         self._settings = {}
 
         self.setupUi(self)
+        self.setUnifiedTitleAndToolBarOnMac(True)
+
+        # This widgets will be disabled when you have no project loaded
+        self.disableWhenNoProjectWidgets = [
+            self.uiGraphicsView,
+            self.uiAnnotateMenu,
+            self.uiAnnotationToolBar,
+            self.uiControlToolBar,
+            self.uiControlMenu,
+            self.uiSaveProjectAsAction,
+            self.uiExportProjectAction,
+            self.uiScreenshotAction,
+            self.uiSnapshotAction,
+            self.uiEditProjectAction,
+            self.uiDeleteProjectAction,
+            self.uiImportExportConfigsAction,
+            self.uiLockAllAction,
+            self.uiShowReadmeAction
+        ]
+
+        for widget in self.disableWhenNoProjectWidgets:
+            widget.setEnabled(False)
+
+        self.disableWhenControllerNotConnectedWidgets = [
+            self.uiNewProjectAction,
+            self.uiOpenProjectAction,
+            self.uiImportProjectAction,
+            self.uiNewTemplateAction,
+            self.uiImportProjectAction,
+            self.uiOpenApplianceAction,
+            self.uiWebUIAction,
+            self.uiNodesDockWidget
+        ]
+
+        for widget in self.disableWhenControllerNotConnectedWidgets:
+            widget.setEnabled(False)
 
         self._notif_dialog = NotifDialog(self)
         # Setup logger
@@ -97,8 +135,6 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         Controller.instance().setParent(self)
         LocalServer.instance().setParent(self)
 
-        HTTPClient.setProgressCallback(Progress.instance(self))
-
         self._first_file_load = True
         self._open_project_path = None
         self._loadSettings()
@@ -109,14 +145,15 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         self.recent_project_actions = []
         self._start_time = time.time()
         local_config = LocalConfig.instance()
-        local_config.config_changed_signal.connect(self._localConfigChangedSlot)
+        #local_config.config_changed_signal.connect(self._localConfigChangedSlot)
         self._local_config_timer = QtCore.QTimer(self)
         self._local_config_timer.timeout.connect(local_config.checkConfigChanged)
         self._local_config_timer.start(1000)  # milliseconds
-        self._analytics_client = AnalyticsClient()
-        self._appliance_manager = ApplianceManager()
+        self._template_manager = TemplateManager().instance()
+        self._appliance_manager = ApplianceManager().instance()
 
         # restore the geometry and state of the main window.
+        self._save_gui_state_geometry = True
         self.restoreGeometry(QtCore.QByteArray().fromBase64(self._settings["geometry"].encode()))
         self.restoreState(QtCore.QByteArray().fromBase64(self._settings["state"].encode()))
 
@@ -138,6 +175,9 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         self._export_configs_to_dir = QtCore.QStandardPaths.writableLocation(QtCore.QStandardPaths.DocumentsLocation)
         self._screenshots_dir = QtCore.QStandardPaths.writableLocation(QtCore.QStandardPaths.PicturesLocation)
         self._pictures_dir = QtCore.QStandardPaths.writableLocation(QtCore.QStandardPaths.PicturesLocation)
+        self._appliance_dir = QtCore.QStandardPaths.writableLocation(QtCore.QStandardPaths.DownloadLocation)
+        self._portable_project_dir = QtCore.QStandardPaths.writableLocation(QtCore.QStandardPaths.DownloadLocation)
+        self._project_dir = None
 
         # add recent file actions to the File menu
         for i in range(0, self._maxrecent_files):
@@ -148,7 +188,7 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         self.uiFileMenu.insertActions(self.uiQuitAction, self.recent_file_actions)
         self.recent_file_actions_separator = self.uiFileMenu.insertSeparator(self.uiQuitAction)
         self.recent_file_actions_separator.setVisible(False)
-        self.updateRecentFileActions()
+        #self.updateRecentFileActions()
 
         # add recent projects to the File menu
         for i in range(0, self._maxrecent_files):
@@ -166,32 +206,11 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         # restore the style
         self._setStyle(self._settings.get("style"))
 
-        if self._settings["hide_new_appliance_template_button"]:
-            self.uiNewAppliancePushButton.hide()
+        if self._settings.get("hide_new_template_button"):
+            self.uiNewTemplatePushButton.hide()
 
         self.setWindowTitle("[*] GNS3")
 
-        # This widgets will be disable when you have no project loaded
-        self.disableWhenNoProjectWidgets = [
-            self.uiGraphicsView,
-            self.uiAnnotateMenu,
-            self.uiAnnotationToolBar,
-            self.uiControlToolBar,
-            self.uiControlMenu,
-            self.uiSaveProjectAsAction,
-            self.uiExportProjectAction,
-            self.uiScreenshotAction,
-            self.uiSnapshotAction,
-            self.uiEditProjectAction,
-            self.uiDeleteProjectAction,
-            self.uiImportExportConfigsAction
-        ]
-
-        # This widgets are not enabled if it's a remote controller (no access to the local file system)
-        self.disableWhenRemoteContollerWidgets = [
-            # self.uiImportExportConfigsAction
-        ]
-
         # load initial stuff once the event loop isn't busy
         self.run_later(0, self.startupLoading)
 
@@ -204,6 +223,8 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         self.uiNewProjectAction.triggered.connect(self._newProjectActionSlot)
         self.uiOpenProjectAction.triggered.connect(self.openProjectActionSlot)
         self.uiOpenApplianceAction.triggered.connect(self.openApplianceActionSlot)
+        self.uiNewTemplateAction.triggered.connect(self._newTemplateActionSlot)
+        self.uiImageManagementAction.triggered.connect(self._imageManagementActionSlot)
         self.uiSaveProjectAsAction.triggered.connect(self._saveProjectAsActionSlot)
         self.uiExportProjectAction.triggered.connect(self._exportProjectActionSlot)
         self.uiImportProjectAction.triggered.connect(self._importProjectActionSlot)
@@ -228,10 +249,14 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         self.uiResetPortLabelsAction.triggered.connect(self._resetPortLabelsActionSlot)
         self.uiShowPortNamesAction.triggered.connect(self._showPortNamesActionSlot)
         self.uiShowGridAction.triggered.connect(self._showGridActionSlot)
+        self.uiShowReadmeAction.triggered.connect(self._showReadmeActionSlot)
         self.uiSnapToGridAction.triggered.connect(self._snapToGridActionSlot)
+        self.uiLockAllAction.triggered.connect(self._lockActionSlot)
+        self.uiResetGUIStateAction.triggered.connect(self._resetGUIState)
+        self.uiResetDocksAction.triggered.connect(self._resetDocksSlot)
 
         # tool menu connections
-        self.uiWebInterfaceAction.triggered.connect(self._openWebInterfaceActionSlot)
+        self.uiWebUIAction.triggered.connect(self._openWebInterfaceActionSlot)
 
         # control menu connections
         self.uiStartAllAction.triggered.connect(self._startAllActionSlot)
@@ -240,6 +265,7 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         self.uiReloadAllAction.triggered.connect(self._reloadAllActionSlot)
         self.uiAuxConsoleAllAction.triggered.connect(self._auxConsoleAllActionSlot)
         self.uiConsoleAllAction.triggered.connect(self._consoleAllActionSlot)
+        self.uiResetConsoleAllAction.triggered.connect(self._consoleResetAllActionSlot)
 
         # device menu is contextual and is build on-the-fly
         self.uiDeviceMenu.aboutToShow.connect(self._deviceMenuActionSlot)
@@ -261,6 +287,7 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         self.uiExportDebugInformationAction.triggered.connect(self._exportDebugInformationSlot)
         self.uiDoctorAction.triggered.connect(self._doctorSlot)
         self.uiAcademyAction.triggered.connect(self._academyActionSlot)
+        self.uiShortcutsAction.triggered.connect(self._shortcutsActionSlot)
 
         # browsers tool bar connections
         self.uiBrowseRoutersAction.triggered.connect(self._browseRoutersActionSlot)
@@ -270,8 +297,8 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         self.uiBrowseAllDevicesAction.triggered.connect(self._browseAllDevicesActionSlot)
         self.uiAddLinkAction.triggered.connect(self._addLinkActionSlot)
 
-        # new appliance button
-        self.uiNewAppliancePushButton.clicked.connect(self._newApplianceActionSlot)
+        # new template button
+        self.uiNewTemplatePushButton.clicked.connect(self._newTemplateActionSlot)
 
         # connect the signal to the view
         self.adding_link_signal.connect(self.uiGraphicsView.addingLinkSlot)
@@ -315,7 +342,9 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
 
     def _openWebInterfaceActionSlot(self):
         if Controller.instance().connected():
-            QtGui.QDesktopServices.openUrl(QtCore.QUrl(Controller.instance().httpClient().fullUrl()))
+            base_url = Controller.instance().httpClient().fullUrl()
+            webui_url = f"{base_url}/static/web-ui/bundled"
+            QtGui.QDesktopServices.openUrl(QtCore.QUrl(webui_url))
 
     def _showGridActionSlot(self):
         """
@@ -342,12 +371,44 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
             project.setSnapToGrid(self.uiSnapToGridAction.isChecked())
             project.update()
 
-    def analyticsClient(self):
+    def _lockActionSlot(self):
         """
-        Return the analytics client
+        Called when user click on the lock menu item
+        :return: None
         """
 
-        return self._analytics_client
+        if self.uiGraphicsView.isEnabled():
+            for item in self.uiGraphicsView.items():
+                if not isinstance(item, LinkItem) and not isinstance(item, LabelItem) and not isinstance(item, SvgIconItem):
+                    if self.uiLockAllAction.isChecked() and not item.locked():
+                        item.setLocked(True)
+                    elif not self.uiLockAllAction.isChecked() and item.locked():
+                        item.setLocked(False)
+                    if item.parentItem() is None:
+                        item.updateNode()
+                    item.update()
+
+    def _resetGUIState(self):
+        """
+        Reset the GUI state.
+        """
+
+        self._save_gui_state_geometry = False
+        self.close()
+        if hasattr(sys, "frozen"):
+            QtCore.QProcess.startDetached(os.path.abspath(sys.executable), sys.argv)
+        else:
+            QtWidgets.QMessageBox.information(self, "GUI state","The GUI state has been reset, please restart the application")
+
+    def _resetDocksSlot(self):
+        """
+        Reset the dock widgets.
+        """
+
+        self.uiTopologySummaryDockWidget.setFloating(False)
+        self.uiComputeSummaryDockWidget.setFloating(False)
+        self.uiConsoleDockWidget.setFloating(False)
+        self.uiNodesDockWidget.setFloating(False)
 
     def _newProjectActionSlot(self):
         """
@@ -361,31 +422,29 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         self._project_dialog = ProjectDialog(self)
         self._project_dialog.show()
         create_new_project = self._project_dialog.exec_()
-        # Close the device dock so it repopulates.  Done in case switching between cloud and local.
-        self.uiNodesDockWidget.setVisible(False)
-        self.uiNodesDockWidget.setWindowTitle("")
 
         if create_new_project:
-            Topology.instance().createLoadProject(
-                self._project_dialog.getProjectSettings())
+            Topology.instance().createLoadProject(self._project_dialog.getProjectSettings())
 
         self._project_dialog = None
 
-    def _newApplianceActionSlot(self):
+    def _newTemplateActionSlot(self):
         """
-        Called when user want to create a new appliance
+        Called when user want to create a new template.
         """
-        dialog = NewApplianceDialog(self)
+
+        dialog = NewTemplateWizard(self)
         dialog.show()
         dialog.exec_()
 
-        # No projects
-        if Topology.instance().project() is None:
-            if self._open_file_at_startup:
-                self.loadPath(self._open_file_at_startup)
-                self._open_file_at_startup = None
-            else:
-                self._newProjectActionSlot()
+    def _imageManagementActionSlot(self):
+        """
+        Called when user wants to manage images
+        """
+
+        dialog = ImageDialog(self)
+        dialog.show()
+        dialog.exec_()
 
     @qslot
     def openApplianceActionSlot(self, *args):
@@ -393,14 +452,15 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         Slot called to open an appliance.
         """
 
-        directory = QtCore.QStandardPaths.writableLocation(QtCore.QStandardPaths.DownloadLocation)
-        if len(directory) == 0:
+        directory = self._appliance_dir
+        if not os.path.exists(self._appliance_dir):
             directory = Topology.instance().projectsDirPath()
-        path, _ = QtWidgets.QFileDialog.getOpenFileName(self, "Open appliance", directory,
-                                                        "All files (*.*);;GNS3 Appliance (*.gns3appliance *.gns3a)",
+        path, _ = QtWidgets.QFileDialog.getOpenFileName(self, "Import appliance", directory,
+                                                        "All files (*);;GNS3 Appliance (*.gns3appliance *.gns3a)",
                                                         "GNS3 Appliance (*.gns3appliance *.gns3a)")
         if path:
             self.loadPath(path)
+            self._appliance_dir = os.path.dirname(path)
 
     def openProjectActionSlot(self):
         """
@@ -411,11 +471,15 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
             # If the server is remote we use the new project windows with the project library
             self._newProjectActionSlot()
         else:
-            path, _ = QtWidgets.QFileDialog.getOpenFileName(self, "Open project", Topology.instance().projectsDirPath(),
-                                                            "All files (*.*);;GNS3 Project (*.gns3);;GNS3 Portable Project (*.gns3project *.gns3p);;NET files (*.net)",
+            directory = self._project_dir
+            if self._project_dir is None or not os.path.exists(self._project_dir):
+                directory = Topology.instance().projectsDirPath()
+            path, _ = QtWidgets.QFileDialog.getOpenFileName(self, "Open project", directory,
+                                                            "All files (*);;GNS3 Project (*.gns3);;GNS3 Portable Project (*.gns3project *.gns3p);;NET files (*.net)",
                                                             "GNS3 Project (*.gns3)")
             if path:
                 self.loadPath(path)
+                self._project_dir = os.path.dirname(path)
 
     def openRecentFileSlot(self):
         """
@@ -478,7 +542,7 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
             self._appliance_wizard.exec_()
         elif path.endswith(".gns3"):
             if Controller.instance().isRemote():
-                QtWidgets.QMessageBox.critical(self, "Open project", "Cannot open a .gns3 file on a remote server, please use a portable project (.gns3p) instead")
+                QtWidgets.QMessageBox.critical(self, "Open project", "Cannot open a .gns3 file on a remote server, please use a project (.gns3p) instead")
                 return
             else:
                 Topology.instance().loadProject(path)
@@ -506,17 +570,20 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         Called when settings are updated
         """
         # It covers case when project is not set
-        # and we need to refresh appliance manager
+        # and we need to refresh template manager
+        # and appliance manager
         project = Topology.instance().project()
         if project is None:
+            self._template_manager.instance().refresh()
             self._appliance_manager.instance().refresh()
 
     def _refreshVisibleWidgets(self):
         """
         Refresh widgets that should be visible or not
         """
-        for widget in self.disableWhenRemoteContollerWidgets:
-            widget.setVisible(not Controller.instance().isRemote())
+
+        for widget in self.disableWhenControllerNotConnectedWidgets:
+            widget.setEnabled(Controller.instance().connected())
 
         # No projects
         if Topology.instance().project() is None:
@@ -536,7 +603,7 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
     def _importExportConfigsActionSlot(self):
         """
         Slot called when importing and exporting configs
-        for the entire topology.
+        for the entire project.
         """
 
         options = ["Export configs to a directory", "Import configs from a directory"]
@@ -715,7 +782,7 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         Slot called to scale in the view.
         """
 
-        factor_in = pow(2.0, 120 / 240.0)
+        factor_in = pow(2.0, 60 / 240.0)
         self.uiGraphicsView.scaleView(factor_in)
         self._updateZoomSettings()
 
@@ -724,7 +791,7 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         Slot called to scale out the view.
         """
 
-        factor_out = pow(2.0, -120 / 240.0)
+        factor_out = pow(2.0, -60 / 240.0)
         self.uiGraphicsView.scaleView(factor_out)
         self._updateZoomSettings()
 
@@ -785,6 +852,13 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         """
         Slot called when starting all the nodes.
         """
+
+        reply = QtWidgets.QMessageBox.question(self, "Confirm Start All", "Are you sure you want to start all devices?",
+                                                   QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No)
+                                                   
+        if reply == QtWidgets.QMessageBox.No:
+            return
+
         project = Topology.instance().project()
         if project is not None:
             project.start_all_nodes()
@@ -794,6 +868,12 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         Slot called when suspending all the nodes.
         """
 
+        reply = QtWidgets.QMessageBox.question(self, "Confirm Suspend All", "Are you sure you want to suspend all devices?",
+                                                   QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No)
+
+        if reply == QtWidgets.QMessageBox.No:
+            return
+
         project = Topology.instance().project()
         if project is not None:
             project.suspend_all_nodes()
@@ -803,6 +883,12 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         Slot called when stopping all the nodes.
         """
 
+        reply = QtWidgets.QMessageBox.question(self, "Confirm Stop All", "Are you sure you want to stop all devices?",
+                                                   QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No)
+
+        if reply == QtWidgets.QMessageBox.No:
+            return
+
         project = Topology.instance().project()
         if project is not None:
             project.stop_all_nodes()
@@ -812,10 +898,25 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         Slot called when reloading all the nodes.
         """
 
+        reply = QtWidgets.QMessageBox.question(self, "Confirm Reload All", "Are you sure you want to reload all devices?",
+                                                   QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No)
+
+        if reply == QtWidgets.QMessageBox.No:
+            return
+
         project = Topology.instance().project()
         if project is not None:
             project.reload_all_nodes()
 
+    def _consoleResetAllActionSlot(self):
+        """
+        Slot called when reset all console connections.
+        """
+
+        project = Topology.instance().project()
+        if project is not None:
+            project.reset_console_all_nodes()
+
     def _deviceMenuActionSlot(self):
         """
         Slot to contextually show the device menu.
@@ -850,7 +951,7 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         Slot called when inserting an image on the scene.
         """
         # supported image file formats
-        file_formats = "Image files (*.svg *.bmp *.jpeg *.jpg *.gif *.pbm *.pgm *.png *.ppm *.xbm *.xpm);;All files (*.*)"
+        file_formats = "Image files (*.svg *.bmp *.jpeg *.jpg *.gif *.pbm *.pgm *.png *.ppm *.xbm *.xpm);;All files (*)"
 
         path, _ = QtWidgets.QFileDialog.getOpenFileName(self, "Image", self._pictures_dir, file_formats)
         if not path:
@@ -886,7 +987,7 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         Slot to launch a browser pointing to the documentation page.
         """
 
-        QtGui.QDesktopServices.openUrl(QtCore.QUrl("https://gns3.com/support/docs"))
+        QtGui.QDesktopServices.openUrl(QtCore.QUrl("https://docs.gns3.com/"))
 
     def _checkForUpdateActionSlot(self, silent=False):
         """
@@ -903,14 +1004,18 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         Slot to open the setup wizard.
         """
 
-        with Progress.instance().context(min_duration=0):
-            setup_wizard = SetupWizard(self)
-            setup_wizard.show()
-            res = setup_wizard.exec_()
-            # start and connect to the local server if needed
-            LocalServer.instance().localServerAutoStartIfRequire()
-            if res:
-                self._newApplianceActionSlot()
+        setup_wizard = SetupWizard(self)
+        setup_wizard.show()
+        setup_wizard.exec_()
+
+    def _shortcutsActionSlot(self):
+
+        shortcuts_text = ""
+        for action in self.findChildren(QtWidgets.QAction):
+            shortcut = action.shortcut().toString()
+            if shortcut:
+                shortcuts_text += f"{action.toolTip()}: {shortcut}\n"
+        QtWidgets.QMessageBox.information(self, "Shortcuts", shortcuts_text)
 
     def _aboutQtActionSlot(self):
         """
@@ -1032,11 +1137,11 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
 
         with Progress.instance().context(min_duration=0):
             dialog = PreferencesDialog(self)
-            dialog.restoreGeometry(QtCore.QByteArray().fromBase64(self._settings["preferences_dialog_geometry"].encode()))
+            #dialog.restoreGeometry(QtCore.QByteArray().fromBase64(self._settings["preferences_dialog_geometry"].encode()))
             dialog.show()
             dialog.exec_()
-            self._settings["preferences_dialog_geometry"] = bytes(dialog.saveGeometry().toBase64()).decode()
-            self.setSettings(self._settings)
+            #self._settings["preferences_dialog_geometry"] = bytes(dialog.saveGeometry().toBase64()).decode()
+            #self.setSettings(self._settings)
 
     def _editReadmeActionSlot(self):
         """
@@ -1044,6 +1149,12 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         """
         Topology.instance().editReadme()
 
+    def _showReadmeActionSlot(self):
+        """
+        Slot to show the README file
+        """
+        Topology.instance().showReadme()
+
     def resizeEvent(self, event):
         self._notif_dialog.resize()
         super().resizeEvent(event)
@@ -1060,6 +1171,10 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         if self.uiAddLinkAction.isChecked() and key == QtCore.Qt.Key_Escape:
             self.uiAddLinkAction.setChecked(False)
             self._addLinkActionSlot()
+        elif key == QtCore.Qt.Key_C and event.modifiers() & QtCore.Qt.ControlModifier:
+            status_bar_message = self.uiStatusBar.currentMessage()
+            if status_bar_message:
+                QtWidgets.QApplication.clipboard().setText(status_bar_message)
         else:
             super().keyPressEvent(event)
 
@@ -1082,8 +1197,6 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         progress.setCancelButtonText("Force quit")
 
         log.debug("Close the Main Window")
-        self._analytics_client.sendScreenView("Main Window", session_start=False)
-
         self._finish_application_closing(close_windows=False)
         event.accept()
         self.uiConsoleTextEdit.closeIO()
@@ -1098,10 +1211,15 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
 
         log.debug("_finish_application_closing")
 
-        self._settings["geometry"] = bytes(self.saveGeometry().toBase64()).decode()
-        self._settings["state"] = bytes(self.saveState().toBase64()).decode()
+        if self._save_gui_state_geometry:
+            self._settings["geometry"] = bytes(self.saveGeometry().toBase64()).decode()
+            self._settings["state"] = bytes(self.saveState().toBase64()).decode()
+        else:
+            self._settings["geometry"] = ""
+            self._settings["state"] = ""
         self.setSettings(self._settings)
 
+        Controller.instance().stopListenNotifications()
         server = LocalServer.instance()
         server.stopLocalServer(wait=True)
 
@@ -1161,8 +1279,9 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
 
         # restore debug level
         if self._settings["debug_level"]:
+            print("Activating debugging (use command 'debug 0' to deactivate)")
             root = logging.getLogger()
-            root.addHandler(logging.StreamHandler(sys.stdout))
+            root.setLevel(logging.DEBUG)
 
         # restore the style
         self._setStyle(self._settings.get("style"))
@@ -1170,20 +1289,17 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
         Controller.instance().connected_signal.connect(self._controllerConnectedSlot)
         Controller.instance().project_list_updated_signal.connect(self.updateRecentProjectActions)
 
-        self._analytics_client.sendScreenView("Main Window")
         self.uiGraphicsView.setEnabled(False)
 
         # show the setup wizard
         if not self._settings["hide_setup_wizard"]:
             self._setupWizardActionSlot()
         else:
-            # start and connect to the local server if needed
-            LocalServer.instance().localServerAutoStartIfRequire()
-            if self._open_file_at_startup:
-                self.loadPath(self._open_file_at_startup)
-                self._open_file_at_startup = None
-            elif Topology.instance().project() is None:
-                self._newProjectActionSlot()
+            if Controller.instance().isRemote():
+                Controller.instance().connect()
+            else:
+                # start and connect to the local server if needed
+                LocalServer.instance().localServerAutoStartIfRequired()
 
         if self._settings["check_for_update"]:
             # automatic check for update every week (604800 seconds)
@@ -1307,7 +1423,15 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
             try:
                 if file_path and os.path.exists(file_path):
                     action = self.recent_file_actions[index]
-                    action.setText(" {}. {}".format(index + 1, os.path.basename(file_path)))
+                    duplicate = False
+                    for file_path_2 in self._settings["recent_files"]:
+                        if file_path != file_path_2 and os.path.basename(file_path) == os.path.basename(file_path_2):
+                            duplicate = True
+                            break
+                    if duplicate:
+                        action.setText(" {}. {} [{}]".format(index + 1, os.path.basename(file_path), file_path))
+                    else:
+                        action.setText(" {}. {}".format(index + 1, os.path.basename(file_path)))
                     action.setData(file_path)
                     action.setVisible(True)
                     index += 1
@@ -1328,9 +1452,17 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
             self.recent_file_actions_separator.setVisible(False)
 
     def _controllerConnectedSlot(self):
+
         self.updateRecentFileActions()
         self._refreshVisibleWidgets()
 
+        if self._settings["hide_setup_wizard"]:
+            if self._open_file_at_startup:
+                self.loadPath(self._open_file_at_startup)
+                self._open_file_at_startup = None
+            elif Topology.instance().project() is None and QtWidgets.QApplication.activeModalWidget() is None:
+                self._newProjectActionSlot()
+
     def run_later(self, counter, callback):
         """
         Run a function after X milliseconds
@@ -1343,23 +1475,25 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
 
     def _exportProjectActionSlot(self):
         """
-        Slot called to export a portable project
+        Slot called to export a project
         """
 
         Topology.instance().exportProject()
 
     def _importProjectActionSlot(self):
         """
-        Slot called to import a portable project
+        Slot called to import a project
         """
-        directory = QtCore.QStandardPaths.writableLocation(QtCore.QStandardPaths.DownloadLocation)
-        if len(directory) == 0:
+
+        directory = self._portable_project_dir
+        if not os.path.exists(directory):
             directory = Topology.instance().projectsDirPath()
-        path, _ = QtWidgets.QFileDialog.getOpenFileName(self, "Open appliance", directory,
-                                                        "All files (*.*);;GNS3 Portable Project (*.gns3project *.gns3p)",
+        path, _ = QtWidgets.QFileDialog.getOpenFileName(self, "Open project", directory,
+                                                        "All files (*);;GNS3 Portable Project (*.gns3project *.gns3p)",
                                                         "GNS3 Portable Project (*.gns3project *.gns3p)")
         if path:
             Topology.instance().importProject(path)
+            self._portable_project_dir = os.path.dirname(path)
 
     def _editProjectActionSlot(self):
         if Topology.instance().project() is None:

gns3/modules/__init__.py

@@ -19,11 +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
 
-#FIXME: removed TraceNG
 MODULES = [Builtin, VPCS, Dynamips, IOU, Qemu, VirtualBox, VMware, Docker]

gns3/modules/builtin/__init__.py

@@ -19,7 +19,6 @@
 Built-in module implementation.
 """
 
-from gns3.qt import QtWidgets
 from gns3.local_config import LocalConfig
 
 from ..module import Module
@@ -29,13 +28,7 @@ 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,
-    CLOUD_SETTINGS,
-    ETHERNET_HUB_SETTINGS,
-    ETHERNET_SWITCH_SETTINGS
-)
+from .settings import BUILTIN_SETTINGS
 
 import logging
 log = logging.getLogger(__name__)
@@ -49,39 +42,8 @@ class Builtin(Module):
 
     def __init__(self):
         super().__init__()
-
-        self._settings = {}
-        self._nodes = []
-        self._cloud_nodes = {}
-        self._nat_nodes = {}
-        self._ethernet_hubs = {}
-        self._ethernet_switches = {}
-
-        # load the settings
         self._loadSettings()
 
-    def configChangedSlot(self):
-
-        pass
-
-    def settings(self):
-        """
-        Returns the module settings
-
-        :returns: module settings (dictionary)
-        """
-
-        return self._settings
-
-    def setSettings(self, settings):
-        """Sets the module settings
-
-        :param settings: module settings (dictionary)
-        """
-
-        self._settings.update(settings)
-        self._saveSettings()
-
     def _saveSettings(self):
         """
         Saves the settings to the persistent settings file.
@@ -89,6 +51,16 @@ class Builtin(Module):
 
         LocalConfig.instance().saveSectionSettings(self.__class__.__name__, self._settings)
 
+        # FIXME: handle server side config
+        # 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)
+        # else:
+        #     config.deleteSetting(self.__class__.__name__, "default_nat_interface")
+
     def _loadSettings(self):
         """
         Loads the settings from the persistent settings file.
@@ -96,183 +68,48 @@ class Builtin(Module):
 
         local_config = LocalConfig.instance()
         self._settings = local_config.loadSectionSettings(self.__class__.__name__, BUILTIN_SETTINGS)
-        self._loadNodes()
-
-    def _loadBuilinNodesPerType(self, node_dict, node_type, default_settings):
-
-        settings = LocalConfig.instance().settings()
-        if node_type in settings.get(self.__class__.__name__, {}):
-            for device in settings[self.__class__.__name__][node_type]:
-                name = device.get("name")
-                server = device.get("server")
-                key = "{server}:{name}".format(server=server, name=name)
-                if key in node_dict or not name or not server:
-                    continue
-                node_settings = default_settings.copy()
-                node_settings.update(device)
-                node_dict[key] = node_settings
-
-    def _loadNodes(self):
-        """
-        Load the built-in nodes from the persistent settings file.
-        """
-
-        self._loadBuilinNodesPerType(self._cloud_nodes, "cloud_nodes", CLOUD_SETTINGS)
-        self._loadBuilinNodesPerType(self._ethernet_hubs, "ethernet_hubs", ETHERNET_HUB_SETTINGS)
-        self._loadBuilinNodesPerType(self._ethernet_switches, "ethernet_switches", ETHERNET_SWITCH_SETTINGS)
-
-    def _saveNodes(self):
-        """
-        Saves the built-in nodes to the persistent settings file.
-        """
-
-        self._settings["cloud_nodes"] = list(self._cloud_nodes.values())
-        self._settings["ethernet_hubs"] = list(self._ethernet_hubs.values())
-        self._settings["ethernet_switches"] = list(self._ethernet_switches.values())
-        self._saveSettings()
-
-    def cloudNodes(self):
-        """
-        Returns cloud nodes settings.
-
-        :returns: Cloud nodes settings (dictionary)
-        """
-
-        return self._cloud_nodes
-
-    def setCloudNodes(self, new_cloud_nodes):
-        """
-        Sets cloud nodes settings.
-
-        :param new_cloud_nodes: cloud nodes settings (dictionary)
-        """
-
-        self._cloud_nodes = new_cloud_nodes.copy()
-        self._saveNodes()
-
-    def ethernetHubs(self):
-        """
-        Returns Ethernet hubs settings.
-
-        :returns: Ethernet hubs settings (dictionary)
-        """
-
-        return self._ethernet_hubs
-
-    def setEthernetHubs(self, new_ethernet_hubs):
-        """
-        Sets Ethernet hubs settings.
-
-        :param new_ethernet_hubs: Ethernet hubs settings (dictionary)
-        """
-
-        self._ethernet_hubs = new_ethernet_hubs.copy()
-        self._saveNodes()
-
-    def ethernetSwitches(self):
-        """
-        Returns Ethernet switches settings.
-
-        :returns: Ethernet switches settings (dictionary)
-        """
-
-        return self._ethernet_switches
-
-    def setEthernetSwitches(self, new_ethernet_switches):
-        """
-        Sets Ethernet switches settings.
-
-        :param new_ethernet_switches: Ethernet switches settings (dictionary)
-        """
-
-        self._ethernet_switches = new_ethernet_switches.copy()
-        self._saveNodes()
-
-    def addNode(self, node):
-        """
-        Adds a node to this module.
-
-        :param node: Node instance
-        """
-
-        self._nodes.append(node)
-
-    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.
-        """
-
-        self._nodes.clear()
-
-    def instantiateNode(self, node_class, server, project):
-        """
-        Instantiate a new node.
-
-        :param node_class: Node object
-        :param server: HTTPClient instance
-        :param project: Project instance
-        """
-
-        # create an instance of the node class
-        return node_class(self, server, project)
 
     @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:
-            QtWidgets.QMessageBox.critical(mainwindow, "Cloud interface", "Could not find interface {} on this host".format(missing_interface))
-            return missing_interface
-
-    @staticmethod
-    def getNodeClass(name):
+    def configurationPage(node_type):
         """
-        Returns the object with the corresponding name.
+        Returns the configuration page for this module.
 
-        :param name: object name
+        :returns: QWidget object
         """
 
-        if name in globals():
-            return globals()[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 getNodeType(name, platform=None):
-        if name == "cloud":
+    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 name == "nat":
+        elif node_type == "nat":
             return Nat
-        elif name == "ethernet_hub":
+        elif node_type == "ethernet_hub":
             return EthernetHub
-        elif name == "ethernet_switch":
+        elif node_type == "ethernet_switch":
             return EthernetSwitch
-        elif name == "frame_relay_switch":
+        elif node_type == "frame_relay_switch":
             return FrameRelaySwitch
-        elif name == "atm_switch":
+        elif node_type == "atm_switch":
             return ATMSwitch
         return None
 
@@ -286,47 +123,6 @@ class Builtin(Module):
 
         return [Nat, Cloud, EthernetHub, EthernetSwitch, FrameRelaySwitch, ATMSwitch]
 
-    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 = []
-        # add custom cloud node templates
-        for cloud_node in self._cloud_nodes.values():
-            nodes.append(
-                {"class": Cloud.__name__,
-                 "name": cloud_node["name"],
-                 "server": cloud_node["server"],
-                 "symbol": cloud_node["symbol"],
-                 "categories": [cloud_node["category"]]
-                 }
-            )
-
-        # add custom Ethernet hub templates
-        for hub in self._ethernet_hubs.values():
-            nodes.append(
-                {"class": EthernetHub.__name__,
-                 "name": hub["name"],
-                 "server": hub["server"],
-                 "symbol": hub["symbol"],
-                 "categories": [hub["category"]]
-                 }
-            )
-
-        # add custom Ethernet switch templates
-        for switch in self._ethernet_switches.values():
-            nodes.append(
-                {"class": EthernetSwitch.__name__,
-                 "name": switch["name"],
-                 "server": switch["server"],
-                 "symbol": switch["symbol"],
-                 "categories": [switch["category"]]
-                }
-            )
-        return nodes
-
     @staticmethod
     def preferencePages():
         """
@@ -351,3 +147,10 @@ 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

@@ -17,7 +17,6 @@
 
 
 import re
-import uuid
 
 from gns3.node import Node
 
@@ -34,6 +33,7 @@ class ATMSwitch(Node):
     :param server: GNS3 server instance
     :param project: Project instance
     """
+
     URL_PREFIX = "atm_switch"
 
     def __init__(self, module, server, project):
@@ -44,36 +44,6 @@ class ATMSwitch(Node):
         self._always_on = True
         self.settings().update({"mappings": {}})
 
-    def _createCallback(self, result):
-        """
-        Callback for create.
-
-        :param result: server response (dict)
-        """
-        self.settings()["mappings"] = result["mappings"]
-
-    def update(self, new_settings):
-        """
-        Updates the settings for this ATM switch.
-
-        :param new_settings: settings dictionary
-        """
-
-        params = {}
-        for name, value in new_settings.items():
-            if name in self._settings and self._settings[name] != value:
-                params[name] = value
-        if params:
-            self._update(params)
-
-    def _updateCallback(self, result):
-        """
-        Callback for update.
-
-        :param result: server response
-        """
-        self.settings()["mappings"] = result["mappings"]
-
     def info(self):
         """
         Returns information about this ATM switch.
@@ -82,14 +52,14 @@ class ATMSwitch(Node):
         """
 
         info = """ATM switch {name} is always-on
-  Local node ID is {id}
-  Server's Node ID is {node_id}
+  Running on server {host} with port {port}
+  Local ID is {id} and node ID is {node_id}
   Hardware is Dynamips emulated simple ATM switch
-  Switch's server runs on {host}
 """.format(name=self.name(),
            id=self.id(),
            node_id=self._node_id,
-           host=self._compute.name())
+           host=self._compute.name(),
+           port=self._compute.port())
 
         port_info = ""
         mapping = re.compile(r"""^([0-9]*):([0-9]*):([0-9]*)$""")
@@ -140,19 +110,6 @@ class ATMSwitch(Node):
 
         return info + port_info
 
-    def dump(self):
-        """
-        Returns a representation of this ATM switch
-        (to be saved in a topology file).
-
-        :returns: dictionary
-        """
-
-        atmsw = super().dump()
-        if self._settings["mappings"]:
-            atmsw["properties"]["mappings"] = self._settings["mappings"]
-        return atmsw
-
     def configPage(self):
         """
         Returns the configuration page widget to be used by the node properties dialog.
@@ -173,11 +130,6 @@ class ATMSwitch(Node):
 
         return ":/symbols/atm_switch.svg"
 
-    @staticmethod
-    def symbolName():
-
-        return "ATM switch"
-
     @staticmethod
     def categories():
         """

gns3/modules/builtin/cloud.py

@@ -16,6 +16,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 from gns3.node import Node
+from .settings import CLOUD_SETTINGS
 
 import logging
 log = logging.getLogger(__name__)
@@ -36,43 +37,33 @@ class Cloud(Node):
     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": []}
+        self._cloud_settings = {"ports_mapping": [],
+                                "usage": "",
+                                "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):
 
         return self._interfaces
 
-    def _createCallback(self, result, error=False, **kwargs):
+    def _createCallback(self, result):
         """
         Callback for create.
 
         :param result: server response
         """
-        if "ports_mapping" in result:
-            self._settings["ports_mapping"] = result["ports_mapping"].copy()
 
         if "interfaces" in result:
             self._interfaces = result["interfaces"].copy()
 
-    def update(self, new_settings, force=False):
-        """
-        Updates the settings for this cloud.
-
-        :param new_settings: settings dictionary
-        :param force: force this node to update
-        """
-
-        params = {}
-        for name, value in new_settings.items():
-            if name in self._settings and self._settings[name] != value:
-                params[name] = value
-        if params or force:
-            self._update(params)
-
     def _updateCallback(self, result):
         """
         Callback for update.
@@ -80,12 +71,42 @@ class Cloud(Node):
         :param result: server response
         """
 
-        if "ports_mapping" in result:
-            self._settings["ports_mapping"] = result["ports_mapping"].copy()
-
         if "interfaces" in result:
             self._interfaces = result["interfaces"].copy()
 
+    def consoleType(self):
+        """
+        Get the console type.
+        """
+
+        return self.settings()["remote_console_type"]
+
+    def consoleHost(self):
+        """
+        Returns the host to connect to the console.
+
+        :returns: host (string)
+        """
+
+        return self.settings()["remote_console_host"]
+
+    def console(self):
+        """
+        Returns the console port number of this node
+
+        :returns: port number
+        """
+
+        return self.settings()["remote_console_port"]
+
+    def consoleHttpPath(self):
+        """
+        Returns the path of the web ui
+
+        :returns: string
+        """
+        return self._settings["remote_console_http_path"]
+
     def info(self):
         """
         Returns information about this cloud.
@@ -93,11 +114,23 @@ class Cloud(Node):
         :returns: formatted string
         """
 
-        info = """Cloud device {name} is always-on
-This is a node for external connections
-Device run on {host}
+        info = """Cloud {name} is always-on
+  Running on server {host} with port {port}
 """.format(name=self.name(),
-           host=self.compute().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
+"""
 
         port_info = ""
         for port in self._ports:
@@ -107,7 +140,8 @@ Device run on {host}
                 port_info += "   Port {name} {description}\n".format(name=port.name(),
                                                                      description=port.description())
 
-        return info + port_info
+        usage = "\n" + self._settings.get("usage")
+        return info + port_info + usage
 
     def configPage(self):
         """
@@ -129,11 +163,6 @@ Device run on {host}
 
         return ":/symbols/cloud.svg"
 
-    @staticmethod
-    def symbolName():
-
-        return "Cloud"
-
     @staticmethod
     def categories():
         """

gns3/modules/builtin/dialogs/cloud_wizard.py

@@ -20,17 +20,15 @@ Wizard for cloud nodes.
 """
 
 from gns3.qt import QtGui, QtWidgets
-from gns3.node import Node
 from gns3.dialogs.vm_wizard import VMWizard
 
 from ..ui.cloud_wizard_ui import Ui_CloudNodeWizard
-from .. import Builtin
 
 
 class CloudWizard(VMWizard, Ui_CloudNodeWizard):
 
     """
-    Wizard to create a cloud node template.
+    Wizard to create a cloud node.
 
     :param parent: parent widget
     """
@@ -50,8 +48,7 @@ class CloudWizard(VMWizard, Ui_CloudNodeWizard):
         """
 
         settings = {"name": self.uiNameLineEdit.text(),
-                    "symbol": ":/symbols/cloud.svg",
-                    "category": Node.end_devices,
-                    "server": self._compute_id}
+                    "symbol": "cloud",
+                    "compute_id": self._compute_id}
 
         return settings