Release v2.2.25

Fix menu disabled for modal dialogs on macOS. Fixes #3007
Change method to display the recent files menu. Fixes #3007
2026-05-28 22:40:30 +03:00 · 2021-09-14 19:20:11 +09:30 · 2021-09-09 21:21:22 +09:30 · 2021-09-09 09:23:45 +09:30 · 2021-09-08 16:16:27 +09:30 · 2021-09-08 15:36:04 +09:30
449 changed files with 138911 additions and 98306 deletions
--- a/.github/ISSUE_TEMPLATE/gns3-bug-report.md
+++ b/.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.
--- a/.github/ISSUE_TEMPLATE/gns3-development.md
+++ b/.github/ISSUE_TEMPLATE/gns3-development.md
@@ -0,0 +1,10 @@
+---
+name: GNS3 development
+about: Any question or discussion regarding GNS3 development
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+
--- a/.github/ISSUE_TEMPLATE/gns3-feature-request.md
+++ b/.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.
--- a/.github/workflows/testing.yml
+++ b/.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@v2
+    - name: Build and run Docker image
+      run: |
+        docker build -t gns3-gui-test .
+        docker run gns3-gui-test
--- a/.pyup.yml
+++ b/.pyup.yml
@@ -1,2 +0,0 @@
-branch:
-    2.2
--- a/.travis.yml
+++ b/.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
--- a/.whitesource
+++ b/.whitesource
@@ -0,0 +1,13 @@
+{
+  "scanSettings": {
+    "configMode": "AUTO",
+    "configExternalURL": "",
+    "projectToken" : ""
+  },
+  "checkRunSettings": {
+    "vulnerableCheckRunConclusionLevel": "failure"
+  },
+  "issueSettings": {
+    "minSeverityLevel": "LOW"
+  }
+}
--- a/552
+++ b/552
@@ -1,5 +1,557 @@
 # Change Log

+## 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
+* 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
+* 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.
+* Fix OverflowError error with progress dialog. Fixes #2767
+* More fixes for stuck progress window. Fixes #2765
+* Fix adding multiple devices - stuck progress window. Fixes #2765
+* Make sure the latest PyQt5 version 5.12.x is used on Windows.
+* Show a warning when a config export is not supported. Ref #2762
+
+## 2.1.15 21/03/2019
+
+* 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.
+
+## 2.1.13 26/02/2019
+
+* Disable computer hibernation detection mechanism. Ref #2678
+* Add some advice for request timeout message. Fixes #2652
+* Show/Hide interface labels when status points are not shown. Fixes #2690
+* Do not print critical message twice on stderr. Replace QMessageBox calls with no parent by log.error()/log.warning().
+* Show critical messages before the main window runs.
+* Avoid using PyQt5.Qt, which imports unneeded stuff. Fixes #2592
+* Fix SIP import error with recent PyQt versions. Fixes #2709
+* Upgrade to Qt 5.12. Fixes #2636
+* Adjust the setup wizard (VMware image size, layouts).
+
+## 2.1.12 23/01/2019
+
+* Option to resize SVG symbols that are too big (height above 80px, activated by default). Ref #2674.
+* Update VMware banners and links.
+* Allow users to refresh the template list in the nodes view panel.
+* Fix Dynamips decompress doesn't work with relative images. Fixes #2648.
+* Update download URL for "Check For Update".
+
+## 2.1.11 28/09/2018
+
+* Handle deleted SIP objects.
+* Update paths for UltraVNC and VirtViewer.
+* Indicate if Solar-PuTTY is included or not. Fixes #2595
+* Fix bad link to installation instructions in README.rst. Fixes #2590
+* Downgrade to Qt 5.9. Fixes #2592.
+
+## 2.1.10 15/09/2018
+
+* Fix small errors like unhandled exceptions etc.
+* Fix when appliance version is not available for Dynamips/IOU/Qemu. Fixes #2585.
+* Fix issue when installing appliance with no version selected. Fixes #2585.
+* Check for existing appliance name across all emulator types. Fixes #2584.
+* Improve the invalid port format detection. Fixes https://github.com/GNS3/gns3-gui/issues/2580
+* Catch OSError/PermissionError when checking md5 on remote image. Fixes #2582.
+* Fix UnicodeDecodeError in file editor. Fixes #2581.
+* Catch import error for win32serviceutil. Fixes #2583.
+* Fix bug with empty project ID when creating a new node. Fixes #2366
+* Fix various small errors, mostly about non-existing C/C++ objects.
+* Send extra controller and compute information in crash reports.
+* Update setup.py and fix minor issues.
+* Set the default delay console all value to 1500ms if using Solar-PuTTY.
+* Make Solar-Putty the default if installed. Ref #2519.
+* Fix issue with custom appliance. Fixes https://github.com/GNS3/gns3-registry/issues/361
+* Forbid controller and compute servers to be different versions. Report last compute server error to clients and display in the server summary.
+* Fix issue with appliance categories. Fixes https://github.com/GNS3/gns3-registry/issues/361
+* Add compute information to crash reports.
+* Add controller version in Sentry bug reports.
+* Backport: Fix "Network session error" issues. Fixes #2560.
+* Add SolarPutty command line. Fixes #2519.
+* Add missing Qemu boot priority values. Fixes https://github.com/GNS3/gns3-server/issues/1385
+* Update PyQt5 from version 5.8 to version 5.10. Fixes #2564.
+
+## 2.1.9 13/08/2018
+
+* Fix incorrect short port names in topology summary. Fixes https://github.com/GNS3/gns3-gui/issues/2562
+* Add compute version in server summary tooltip.
+* Fix test for Qemu boot priority. Fixes #2548.
+* Fix boot priority missing when installing an appliance. Fixes #2548.
+* Support PATH with UTF-8 characters in OSX telnet console, fixes #2537
+* Allow users to accept different MD5 hashes for preconfigured appliances. Fixes #2526.
+* Do not try to update drawing if it is being deleted. Ref #2483.
+* Catch exception when loading invalid appliance file.
+
+## 2.1.8 14/06/2018
+
+* Add error information when cannot access/read IOS/IOU config file. Ref #2501
+* Fallback when using process name to bring console to front.
+* Use process name to bring console to front. Fixes #2514.
+
+## 2.1.7 12/06/2018
+
+* Do not try to update link if it is being deleted. Fixes #2483.
+* Fix can't add SVG image to project. Fixes #2502
+* Remove unwanted trailing characters and other white spaces when reading .md5sum files. Fixes #2498.
+* Update interface sequence number check. Fixes #2491.
+* Logo should not have context menu, Fixes: #2507
+* Update logo position only when changes, Fixes: #2506
+
+## 2.1.6 22/05/2018
+
+* Ask for global variables when project is loaded
+* Add/Edit global variables of project
+* Rename tabs at Edit Project
+* Global variables tab on Edit project
+* Support of supplier logo and url
+* Add missing crowdfunder name in About dialog.
+* Project variables and supplier
+* No timeout when duplicating a project.
+* No timeout when restoring snapshot.
+* Add advanced settings for docker and ExtraHosts param, Ref. #2482
+* Replace "not supported" by "none" in topology summary view.
+
+## 2.1.5 18/04/2018
+
+* Fix Qemu binary list locks when a version is deleted. Fixes #2474.
+* Fix invalid answer from the PyPi server. Fixes #2473.
+* Fix wrong wizard page name.
+* Grid size support for projects. Fixes #2469.
+* Remove 'include INSTALL' from MANIFEST. Fixes #2470.
+* Check for valid IP address and prevent to run on non-Windows platforms.
+
 ## 2.1.4 12/03/2018

 * Update node on server on any change, Fixes: #2429
--- a/8
+++ b/8
@@ -1,22 +1,16 @@
 # Run tests inside a container
-FROM ubuntu:17.10
-
+FROM ubuntu:18.04
 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 clean

-
 ADD dev-requirements.txt /dev-requirements.txt
 ADD requirements.txt /requirements.txt
 RUN pip3 install -r /dev-requirements.txt

-
 ADD . /src
-
 WORKDIR /src

 CMD xvfb-run python3.6 -m pytest -vv
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1,10 +1,8 @@
 include README.rst
 include AUTHORS
-include INSTALL
 include LICENSE
 include MANIFEST.in
 include requirements.txt
-include tox.ini
 recursive-include tests *
 recursive-include gns3 *
 recursive-include resources *
--- a/README.rst
+++ b/README.rst
@@ -1,19 +1,31 @@
 GNS3-gui
 ========

-.. image:: https://travis-ci.org/GNS3/gns3-gui.svg?branch=master
-    :target: https://travis-ci.org/GNS3/gns3-gui
+.. image:: https://github.com/GNS3/gns3-gui/workflows/testing/badge.svg
+    :target: https://github.com/GNS3/gns3-gui/actions?query=workflow%3Atesting

 .. image:: https://img.shields.io/pypi/v/gns3-gui.svg
    :target: https://pypi.python.org/pypi/gns3-gui

+.. image:: https://snyk.io/test/github/GNS3/gns3-gui/badge.svg
+    :target: https://snyk.io/test/github/GNS3/gns3-gui
+

 GNS3 GUI repository.

 Installation
 ------------

-https://gns3.com/support/docs
+Please see 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/master/requirements.txt>`_
+
+For connecting to nodes using Telnet, a Telnet client is required. On Linux that's a terminal emulator like xterm, gnome-terminal, konsole plus the telnet program. For connecting to nodes with a GUI, a VNC client is required, optionally a SPICE client can be used for Qemu nodes.
+
+For using packet captures within GNS3, Wireshark should be installed. It's recommended, but if you don't need that functionality you can go without it.

 Development
 -------------
@@ -42,6 +54,7 @@ https://github.com/Kozea/wdb

 Security issues
 ----------------
-Please contact us using contact informations available here:
-http://docs.gns3.com/1ON9JBXSeR7Nt2-Qum2o3ZX0GU86BZwlmNSUgvmqNWGY/index.html
+
+Please contact us at security@gns3.net
+

--- a/appveyor.yml
+++ b/appveyor.yml
@@ -1,6 +1,6 @@
 version: '{build}-{branch}'

-image: Visual Studio 2015
+image: Visual Studio 2017

 platform: x64

--- a/dev-requirements.txt
+++ b/dev-requirements.txt
@@ -1,6 +1,5 @@
 -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==6.2.4
+flake8==3.9.2
+pytest-timeout==1.4.2
--- a/gns3/appliance_manager.py
+++ b/gns3/appliance_manager.py
@@ -17,96 +17,70 @@

 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
+

 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:
+                self._controller.get("/appliances?update=yes&symbol_theme={}".format(symbol_theme), self._listAppliancesCallback, progressText="Downloading appliances from online registry...")
+            else:
+                self._controller.get("/appliances?symbol_theme={}".format(symbol_theme), self._listAppliancesCallback)

    def _controllerDisconnectedSlot(self):
-        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["message"]))
+            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["message"]))
-            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
-
-        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)
-            },
-                timeout=None)
-        else:
-            self._controller.post("/projects/" + project_id + "/appliances/" + appliance_id, self._createNodeFromApplianceCallback, {
-                "x": int(x),
-                "y": int(y)
-            },
-                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():
        """
--- a/gns3/base_node.py
+++ b/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,72 +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
-        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)
+        categories = {"Routers": BaseNode.routers,
+                      "Switches": BaseNode.switches,
+                      "End devices": BaseNode.end_devices,
+                      "Security devices": BaseNode.security_devices}

-    def _exportConfigToDirectoryCallback(self, result, error=False, raw_body=None, context={}, **kwargs):
+        return categories
+
+    @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
-            # exemple
-            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()
--- a/gns3/compute.py
+++ b/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,85 +37,211 @@ class Compute:
        self._password = None
        self._cpu_usage_percent = None
        self._memory_usage_percent = None
-        self._capabilities = {
-            "node_types": []
-        }
+        self._capabilities = {"node_types": []}
+        self._last_error = None

    def id(self):
+        """
+        Returns the compute ID.
+
+        :returns: compute identifier
+        """
+
        return self._compute_id

    def name(self):
+        """
+        Returns the compute name.
+
+        :returns: compute name
+        """
+
        return self._name

    def setName(self, name):
+        """
+        Sets the compute name.
+
+        :param name: compute name
+        """
+
        self._name = name

    def connected(self):
+        """
+        Returns whether or not there is a connection to the compute.
+
+        :returns: boolean
+        """
+
        return self._connected

    def setConnected(self, value):
+        """
+        Sets whether or not there is a connection to the compute.
+
+        :param value: boolean
+        """
+
        self._connected = value

-    def 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 capabilities(self):
+        """
+        Returns the compute capabilities
+
+        :returns: capabilities (dictionary)
+        """
+
        return self._capabilities

-    def setCapabilities(self, val):
-        self._capabilities = val
+    def setCapabilities(self, value):
+        """
+        Sets the compute capabilities
+
+        :param value: capabilities (dictionary)
+        """
+
+        self._capabilities = value
+
+    def setLastError(self, last_error):
+        self._last_error = last_error
+
+    def lastError(self):
+        return self._last_error

    def __str__(self):
+
        return self._compute_id

    def __json__(self):
-        return {
-            "host": self._host,
-            "port": self._port,
-            "protocol": self._protocol,
-            "user": self._user,
-            "password": self._password,
-            "name": self._name,
-            "compute_id": self._compute_id
-        }
+
+        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
--- a/gns3/compute_manager.py
+++ b/gns3/compute_manager.py
@@ -16,7 +16,6 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.

 from .qt import QtCore
-
 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,7 +47,7 @@ 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()
@@ -53,6 +57,10 @@ class ComputeManager(QtCore.QObject):
        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:
@@ -61,16 +69,28 @@ class ComputeManager(QtCore.QObject):
            self._controller.get("/computes", self._listComputesCallback, showProgress=False, timeout=30)

    def _controllerConnectedSlot(self):
+        """
+        Called when connected to a compute.
+        """
+
        if self._controller.connected():
            self._refreshingComputes = True
            self._controller.get("/computes", self._listComputesCallback, showProgress=False, timeout=30)

    def _controllerDisconnectedSlot(self):
+        """
+        Called when disconnected from a compute.
+        """
+
        for compute_id in list(self._computes):
            del self._computes[compute_id]
            self.deleted_signal.emit(compute_id)

    def _listComputesCallback(self, result, error=False, **kwargs):
+        """
+        Callback to list computes.
+        """
+
        self._refreshingComputes = False
        if error is True:
            log.error("Error while getting compute list: {}".format(result["message"]))
@@ -81,8 +101,7 @@ class ComputeManager(QtCore.QObject):

    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()
@@ -102,6 +121,7 @@ class ComputeManager(QtCore.QObject):
        self._computes[compute_id].setCpuUsagePercent(compute["cpu_usage_percent"])
        self._computes[compute_id].setMemoryUsagePercent(compute["memory_usage_percent"])
        self._computes[compute_id].setCapabilities(compute["capabilities"])
+        self._computes[compute_id].setLastError(compute.get("last_error"))

        if new_node:
            self.created_signal.emit(compute_id)
@@ -110,8 +130,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
@@ -121,6 +142,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
@@ -132,6 +154,7 @@ class ComputeManager(QtCore.QObject):
        """
        :returns: The GNS3 VM compute node or None
        """
+
        try:
            return self._computes["vm"]
        except KeyError:
@@ -141,6 +164,7 @@ class ComputeManager(QtCore.QObject):
        """
        :returns: The local compute node or None
        """
+
        try:
            return self._computes["local"]
        except KeyError:
@@ -152,6 +176,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
@@ -161,31 +186,45 @@ 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 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"]:
--- a/gns3/compute_summary_view.py
+++ b/gns3/compute_summary_view.py
@@ -29,7 +29,6 @@ log = logging.getLogger(__name__)


 class ComputeItem(QtWidgets.QTreeWidgetItem):
-
    """
    Custom item for the QTreeWidget instance
    (topology summary view).
@@ -62,19 +61,26 @@ class ComputeItem(QtWidgets.QTreeWidgetItem):
            text = "{} CPU {}%, RAM {}%".format(text, self._compute.cpuUsagePercent(), self._compute.memoryUsagePercent())

        self.setText(0, text)
-        self.setToolTip(0, text + " on " + self._compute.capabilities().get("platform", ""))
-
        if self._compute.connected():
            self._status = "connected"
+            self.setToolTip(0, "Server {} version {} running on {}".format(self._compute.name(),
+                                                                           self._compute.capabilities().get("version", "n/a"),
+                                                                           self._compute.capabilities().get("platform", "")))
            if usage is None or (self._compute.cpuUsagePercent() < 90 and self._compute.memoryUsagePercent() < 90):
                self.setIcon(0, QtGui.QIcon(':/icons/led_green.svg'))
            else:
                self.setIcon(0, QtGui.QIcon(':/icons/led_yellow.svg'))
        else:
-            if self._status == "unknown":
+            last_error = self._compute.lastError()
+            if last_error:
+                self.setToolTip(0, "Failed to connect to {}: {}".format(self._compute.name(), last_error))
+                self.setIcon(0, QtGui.QIcon(':/icons/led_red.svg'))
+            elif self._status == "unknown":
+                self.setToolTip(0, "Discovering or connecting to {}...".format(self._compute.name()))
                self.setIcon(0, QtGui.QIcon(':/icons/led_gray.svg'))
            else:
                self._status = "stopped"
+                self.setToolTip(0, "{} is stopped or cannot be reached".format(self._compute.name()))
                self.setIcon(0, QtGui.QIcon(':/icons/led_red.svg'))
        self._parent.sortItems(0, QtCore.Qt.AscendingOrder)

@@ -94,8 +100,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.

@@ -105,9 +111,7 @@ class ComputeSummaryView(QtWidgets.QTreeWidget):
    def __init__(self, parent):

        super().__init__(parent)
-
        self._computes = {}
-
        ComputeManager.instance().created_signal.connect(self._computeAddedSlot)
        ComputeManager.instance().updated_signal.connect(self._computeUpdatedSlot)
        ComputeManager.instance().deleted_signal.connect(self._computeRemovedSlot)
--- a/gns3/console_cmd.py
+++ b/gns3/console_cmd.py
@@ -22,8 +22,7 @@ Handles commands typed in the GNS3 console.
 import sys
 import cmd
 import struct
-import sip
-import json
+from .qt import sip

 from .node import Node
 from .qt import QtCore
@@ -224,17 +223,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:
--- a/gns3/console_view.py
+++ b/gns3/console_view.py
@@ -16,13 +16,13 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.

 import sys
-import sip
+from .qt import sip
 import struct
 import inspect
 import datetime
 import platform

-from .qt import QtCore, Qt
+from .qt import QtCore
 from .topology import Topology
 from .version import __version__
 from .console_cmd import ConsoleCmd
@@ -75,7 +75,7 @@ class ConsoleView(PyCutExt, ConsoleCmd):
        self.intro = "GNS3 management console.\nRunning GNS3 version {} on {} ({}-bit) with Python {} Qt {} and PyQt {}.\n" \
                     "Copyright (c) 2006-{} GNS3 Technologies.\n" \
                     "Use Help -> GNS3 Doctor to detect common issues." \
-                     "".format(__version__, platform.system(), bitness, platform.python_version(), QtCore.QT_VERSION_STR, Qt.PYQT_VERSION_STR, current_year)
+                     "".format(__version__, platform.system(), bitness, platform.python_version(), QtCore.QT_VERSION_STR, QtCore.PYQT_VERSION_STR, current_year)

        # Parent class initialization
        try:
@@ -110,6 +110,9 @@ class ConsoleView(PyCutExt, ConsoleCmd):
        self._topology = Topology.instance()

    def _writeMessageSlot(self, message, level):
+        """
+        Write a message in the console.
+        """
        if level == "error":
            self.write(message, error=True)
        elif level == "warning":
--- a/gns3/controller.py
+++ b/gns3/controller.py
@@ -18,11 +18,14 @@
 import os
 import hashlib
 import tempfile
+import json
+import pathlib

-from .qt import QtCore, QtGui, QtWidgets, qpartial, qslot
+from .qt import QtCore, QtNetwork, QtGui, QtWidgets, QtWebSockets, qpartial, qslot
 from .symbol import Symbol
 from .local_server_config import LocalServerConfig
 from .settings import LOCAL_SERVER_SETTINGS
+from gns3.utils import parse_version

 import logging
 log = logging.getLogger(__name__)
@@ -30,35 +33,44 @@ 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()

-    def __init__(self, parent=None):
+    def __init__(self):
+
        super().__init__()
        self._connected = False
        self._connecting = False
-        self._cache_directory = tempfile.mkdtemp()
+        self._notification_stream = None
+        self._version = None
+        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._websocket = QtWebSockets.QWebSocket()

        # If we do multiple call in order to download the same symbol we queue them
        self._static_asset_download_queue = {}

    def host(self):
+
        return self._http_client.host()

+    def version(self):
+        return self._version
+
    def isRemote(self):
        """
        :returns Boolean: True if the controller is remote
        """
+
        settings = LocalServerConfig.instance().loadSettings("Server", LOCAL_SERVER_SETTINGS)
        return not settings["auto_start"]

@@ -66,24 +78,28 @@ class Controller(QtCore.QObject):
        """
        :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():
@@ -96,12 +112,14 @@ class Controller(QtCore.QObject):
        """
        :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

@@ -109,32 +127,39 @@ class Controller(QtCore.QObject):
        """
        Connection process as started
        """
+
        self._connected = False
        self._connecting = True
-        self.get('/version', self._versionGetSlot)
+        status, json_data = self.httpClient().getSynchronous('GET', '/version', timeout=60)
+        self._versionGetSlot(json_data, status is None or status >= 300)

    def _httpClientDisconnectedSlot(self):
        if self._connected:
            self._connected = False
            self.disconnected_signal.emit()
            self._connectingToServer()
+            self.stopListenNotifications()

    def _versionGetSlot(self, result, error=False, **kwargs):
        """
-        Called after the inital version get
+        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:
+                if 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"]))
+                    if result and "message" in result:
+                        self._error_dialog.setText("Error when connecting to the GNS3 server:\n{}".format(result["message"]))
+                    else:
+                        self._error_dialog.setText("Cannot connect to the GNS3 server")
                    self._error_dialog.setIcon(QtWidgets.QMessageBox.Critical)
                    self._error_dialog.show()
-            # Try to connect again in x seconds
+            # Try to connect again in 5 seconds
            QtCore.QTimer.singleShot(5000, qpartial(self.get, '/version', self._versionGetSlot, showProgress=self._first_error))
            self._first_error = False
        else:
@@ -142,32 +167,44 @@ class Controller(QtCore.QObject):
            if self._error_dialog:
                self._error_dialog.reject()
                self._error_dialog = None
+            self._version = result.get("version")
+            self._http_client.connection_connected_signal.emit()

    def _httpClientConnectedSlot(self):
+
        if not self._connected:
            self._connected = True
            self._connecting = False
            self.connected_signal.emit()
            self.refreshProjectList()
+            self._startListenNotifications()
+
+    def post(self, *args, **kwargs):
+        return self.createHTTPQuery("POST", *args, **kwargs)

    def get(self, *args, **kwargs):
        return self.createHTTPQuery("GET", *args, **kwargs)

+    def put(self, *args, **kwargs):
+        return self.createHTTPQuery("PUT", *args, **kwargs)
+
+    def delete(self, *args, **kwargs):
+        return self.createHTTPQuery("DELETE", *args, **kwargs)
+
    def getCompute(self, path, compute_id, *args, **kwargs):
        """
        API get on a specific compute
        """
+
        compute_id = self.__fix_compute_id(compute_id)
        path = "/computes/{}{}".format(compute_id, path)
        return self.get(path, *args, **kwargs)

-    def 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)
@@ -176,9 +213,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:
@@ -191,29 +229,28 @@ class Controller(QtCore.QObject):
        """
        API post on a specific compute
        """
+
        compute_id = self.__fix_compute_id(compute_id)
        path = "/computes/endpoint/{}{}".format(compute_id, path)
        return self.get(path, *args, **kwargs)

-    def put(self, *args, **kwargs):
-        return self.createHTTPQuery("PUT", *args, **kwargs)
+    def putCompute(self, path, compute_id, *args, **kwargs):
+        """
+        API put on a specific compute
+        """

-    def delete(self, *args, **kwargs):
-        return self.createHTTPQuery("DELETE", *args, **kwargs)
+        compute_id = self.__fix_compute_id(compute_id)
+        path = "/computes/{}{}".format(compute_id, path)
+        return self.put(path, *args, **kwargs)

    def createHTTPQuery(self, method, path, *args, **kwargs):
        """
        Forward the query to the HTTP client or controller depending 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)
-
    @staticmethod
    def instance():
        """
@@ -237,7 +274,6 @@ class Controller(QtCore.QObject):
        if not self._http_client:
            return

-
        path = self.getStaticCachedPath(url)

        if os.path.exists(path):
@@ -276,8 +312,8 @@ class Controller(QtCore.QObject):
    def getStaticCachedPath(self, url):
        """
        Returns static cached (hashed) path
+
        :param url:
-        :return:
        """
        m = hashlib.md5()
        m.update(url.encode())
@@ -285,9 +321,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
@@ -304,10 +353,31 @@ 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), progressText="Uploading {}".format(symbol_id), timeout=None)
+
+    def _finishSymbolUpload(self, path, result, error=False, **kwargs):
+
+        if error:
+            log.error("Error while uploading symbol: {}: {}".format(path, result.get("message", "unknown")))
+            return
+
+        # Refresh the templates list
+        from .template_manager import TemplateManager
+        TemplateManager.instance().templates_changed_signal.emit()
+
    def getSymbols(self, callback):
        self.get('/symbols', callback=callback)

@@ -336,3 +406,84 @@ class Controller(QtCore.QObject):

    def projects(self):
        return self._projects
+
+    def _startListenNotifications(self):
+        if not self.connected():
+            return
+
+        # Due to bug in Qt on some version we need a dedicated network manager
+        self._notification_network_manager = QtNetwork.QNetworkAccessManager()
+        self._notification_stream = None
+
+        # Qt websocket before Qt 5.6 doesn't support auth
+        if parse_version(QtCore.QT_VERSION_STR) < parse_version("5.6.0") or parse_version(QtCore.PYQT_VERSION_STR) < parse_version("5.6.0"):
+            self._notification_stream = Controller.instance().createHTTPQuery("GET", "/notifications", self._endListenNotificationCallback,
+                                                                              downloadProgressCallback=self._event_received,
+                                                                              networkManager=self._notification_network_manager,
+                                                                              timeout=None,
+                                                                              showProgress=False,
+                                                                              ignoreErrors=True)
+
+        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)
+
+    def stopListenNotifications(self):
+        if self._notification_stream:
+            log.debug("Stop listening for notifications from controller")
+            stream = self._notification_stream
+            self._notification_stream = None
+            stream.abort()
+            self._notification_network_manager = None
+
+    def _endListenNotificationCallback(self, result, error=False, **kwargs):
+        """
+        If notification stream disconnect we reconnect to it
+        """
+        if self._notification_stream:
+            self._notification_stream = None
+            self._startListenNotifications()
+
+    @qslot
+    def _websocket_error(self, error):
+        if self._notification_stream:
+            log.error("Websocket notification stream error: {}".format(self._notification_stream.errorString()))
+            self._notification_stream = None
+            self._startListenNotifications()
+
+    @qslot
+    def _sslErrorsSlot(self, ssl_errors):
+
+        self._http_client.handleSslError(self._notification_stream, ssl_errors)
+
+    @qslot
+    def _websocket_event_received(self, event):
+        try:
+            self._event_received(json.loads(event))
+        except ValueError as e:
+            log.error("Invalid event received: {}".format(e))
+
+    def _event_received(self, result, *args, **kwargs):
+
+        # Log only relevant events
+        if result["action"] not in ("ping", "compute.updated"):
+            log.debug("Event received from controller stream: {}".format(result))
+        if result["action"] == "template.created" or result["action"] == "template.updated":
+            from gns3.template_manager import TemplateManager
+            TemplateManager.instance().templateDataReceivedCallback(result["event"])
+        elif result["action"] == "template.deleted":
+            from gns3.template_manager import TemplateManager
+            TemplateManager.instance().deleteTemplateCallback(result["event"])
+        elif result["action"] == "compute.created" or result["action"] == "compute.updated":
+            from .compute_manager import ComputeManager
+            ComputeManager.instance().computeDataReceivedCallback(result["event"])
+        elif result["action"] == "log.error":
+            log.error(result["event"]["message"])
+        elif result["action"] == "log.warning":
+            log.warning(result["event"]["message"])
+        elif result["action"] == "log.info":
+            log.info(result["event"]["message"], extra={"show": True})
+        elif result["action"] == "ping":
+            pass
--- a/gns3/crash_report.py
+++ b/gns3/crash_report.py
@@ -16,18 +16,18 @@
 # 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__
@@ -51,52 +51,52 @@ class CrashReport:
    Report crash to a third party service
    """

-    DSN = "sync+https://b892f3e4a56e4443ad16cfe3d4c6d602:ca3ad57e613441ab95ea15a45e9e5435@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://ca0e3be7dada465495fc33615f6143b8:4ddf20c171744e138fd327929c5e15f2@o19455.ingest.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
+        if SENTRY_SDK_AVAILABLE:
+            cacert = None
+            if hasattr(sys, "frozen"):
+                cacert_resource = get_resource("cacert.pem")
+                if cacert_resource is not None and os.path.isfile(cacert_resource):
+                    cacert = cacert_resource
+                else:
+                    log.error("The SSL certificate bundle file '{}' could not be found".format(cacert_resource))

-        local_server = LocalServer.instance().localServerSettings()
-        if local_server["report_errors"]:
-            if not RAVEN_AVAILABLE:
-                return
+            # Don't send log records as events.
+            sentry_logging = LoggingIntegration(level=logging.INFO, event_level=None)

-            if os.path.exists(LocalConfig.instance().runAsRootPath()):
-                log.warning("User has run application as root. Crash reports are disabled.")
-                sys.exit(1)
-                return
+            sentry_sdk.init(dsn=CrashReport.DSN,
+                            release=__version__,
+                            ca_certs=cacert,
+                            default_integrations=False,
+                            integrations=[sentry_logging])

-            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": " ".join(distro.linux_distribution()),
+
+            }
+
+            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]),
@@ -104,26 +104,64 @@ class CrashReport:
                "python:encoding": sys.getdefaultencoding(),
                "python:frozen": "{}".format(hasattr(sys, "frozen"))
            }
-            context = self._add_qt_information(context)
-            client.tags_context(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)))

-    def _add_qt_information(self, context):
+            # extra controller and compute information
+            from .controller import Controller
+            from .compute_manager import ComputeManager
+            extra_context["controller:version"] = Controller.instance().version()
+            extra_context["controller:host"] = Controller.instance().host()
+            extra_context["controller:connected"] = Controller.instance().connected()
+
+            for index, compute in enumerate(ComputeManager.instance().computes()):
+                extra_context["compute{}:id".format(index)] = compute.id()
+                extra_context["compute{}:name".format(index)] = compute.name(),
+                extra_context["compute{}:host".format(index)] = compute.host(),
+                extra_context["compute{}:connected".format(index)] = compute.connected()
+                extra_context["compute{}:platform".format(index)] = compute.capabilities().get("platform")
+                extra_context["compute{}:version".format(index)] = compute.capabilities().get("version")
+
+            with sentry_sdk.configure_scope() as scope:
+                for key, value in extra_context.items():
+                    scope.set_extra(key, value)
+
+    def captureException(self, exception, value, tb):
+
+        from .local_server import LocalServer
+        from .local_config import LocalConfig
+
+        local_server = LocalServer.instance().localServerSettings()
+        if local_server["report_errors"]:
+
+            if not SENTRY_SDK_AVAILABLE:
+                log.warning("Cannot capture exception: Sentry SDK is not available")
+                return
+
+            if os.path.exists(LocalConfig.instance().runAsRootPath()):
+                log.warning("User is running application as root. Crash reports disabled.")
+                return
+
+            if not hasattr(sys, "frozen") and os.path.exists(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", ".git")):
+                log.warning(".git directory detected, crash reporting is turned off for developers.")
+                return
+
+            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):
+
        try:
            from .qt import QtCore
-            import sip
+            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):
--- a/gns3/dialogs/appliance_wizard.py
+++ b/gns3/dialogs/appliance_wizard.py
@@ -16,15 +16,18 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.

 import os
-import sip
+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.wait_for_lambda_worker import WaitForLambdaWorker
@@ -33,12 +36,14 @@ 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,31 +51,54 @@ 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._server_check = 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()
+
+        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
+        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)
@@ -80,75 +108,54 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
            self.uiLocalRadioButton.setText("Install the appliance on the main server")
        else:
            if not path.endswith('.builtin.gns3a'):
-                destination = Config().appliances_dir
+                destination = None
                try:
-                    os.makedirs(destination, exist_ok=True)
-                    destination = os.path.join(destination, os.path.basename(path))
-                    shutil.copy(path, destination)
+                    destination = Config().appliances_dir
                except OSError as e:
-                    QtWidgets.QMessageBox.warning(self.parent(), "Can't copy {} to {}".format(path, destination), str(e))
+                    QtWidgets.QMessageBox.critical(self.parent(), "Add appliance", "Could not find configuration file: {}".format(e))
+                except ValueError as e:
+                    QtWidgets.QMessageBox.critical(self.parent(), "Add appliance", "Invalid configuration file: {}".format(e))
+                if destination:
+                    try:
+                        os.makedirs(destination, exist_ok=True)
+                        destination = os.path.join(destination, os.path.basename(path))
+                        shutil.copy(path, destination)
+                    except OSError as e:
+                        QtWidgets.QMessageBox.warning(self.parent(), "Cannot copy {} to {}".format(path, destination), str(e))

        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"
        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"])
+            if "qemu" in self._appliance:
+                emulator_type = "qemu"
+            elif "iou" in self._appliance:
+                emulator_type = "iou"
+            elif "docker" in self._appliance:
+                emulator_type = "docker"
+            elif "dynamips" in self._appliance:
+                emulator_type = "dynamips"
+            else:
+                QtWidgets.QMessageBox.warning(self, "Appliance", "Could not determine the emulator type")

-            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")

@@ -166,11 +173,11 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
            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 emulator_type == "qemu":
+                    # disallow usage of the local server because Qemu has issues on OSX and Windows
                    if not LocalConfig.instance().experimental():
                        self.uiLocalRadioButton.setEnabled(False)
-                elif type != "dynamips":
+                elif emulator_type != "dynamips":
                    self.uiLocalRadioButton.setEnabled(False)

            if ComputeManager.instance().vmCompute():
@@ -183,81 +190,138 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
                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.")
+                if not self.uiRemoteRadioButton.isEnabled() and not self.uiVMRadioButton.isEnabled() and not self.uiLocalRadioButton.isEnabled():
+                    QtWidgets.QMessageBox.warning(self, "GNS3 VM", "The GNS3 VM is not available, please configure the GNS3 VM before adding a 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(self._appliance.emulator(), self._compute_id)
+            else:
+                self.images_changed_signal.emit()

        elif self.page(page_id) == self.uiQemuWizardPage:
+            if self._appliance['qemu'].get('kvm', 'require') == 'require':
+                self._server_check = False
+                Qemu.instance().getQemuCapabilitiesFromServer(self._compute_id, qpartial(self._qemuServerCapabilitiesCallback))
+            else:
+                self._server_check = True
            Qemu.instance().getQemuBinariesFromServer(self._compute_id, qpartial(self._getQemuBinariesFromServerCallback), [self._appliance["qemu"]["arch"]])

-        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)
-
        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", ""))
-            )
-
-        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
+            self.uiUsageTextEdit.setText("The template will be available in the {} category.\n\n{}".format(self._appliance["category"].replace("_", " "), self._appliance.get("usage", "")))

    def _qemuServerCapabilitiesCallback(self, result, error=None, *args, **kwargs):
        """
-        Check if server support KVM or not
+        Check if the server supports 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)
+                msg = "The selected server does not support KVM. A Linux server or the GNS3 VM running in VMware is required."
+            QtWidgets.QMessageBox.critical(self, "KVM support", msg)
            self._server_check = False

    def _uiServerWizardPage_isComplete(self):
        return self.uiRemoteRadioButton.isEnabled() or self.uiVMRadioButton.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(self._appliance.emulator(), self._compute_id)
+
+    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()
@@ -267,13 +331,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():
@@ -281,19 +346,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_filesize(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(2, image["path"])

                # Associated data stored are col 0: version, col 1: image
                image_widget.setData(0, QtCore.Qt.UserRole, version)
@@ -307,26 +367,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_filesize(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:
@@ -334,7 +398,7 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):

    def _refreshDialogWorker(self):
        """
-        Scan local directory in order to found the images on disk
+        Scan local directory in order to find images on the disk
        """

        # Docker do not have versions
@@ -343,11 +407,20 @@ 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.emulator(),
+                                                       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
@@ -358,9 +431,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
@@ -374,9 +447,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

@@ -390,7 +464,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"]))
@@ -401,8 +475,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:
@@ -413,9 +503,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

@@ -431,15 +522,16 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
        image = Image(self._appliance.emulator(), path, filename=disk["filename"])
        try:
            if "md5sum" in disk and image.md5sum != disk["md5sum"]:
-                QtWidgets.QMessageBox.warning(self.parent(), "Add appliance", "This is not the correct file. The MD5 sum is {} and should be {}.".format(image.md5sum, disk["md5sum"]))
-                return
+                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)
+                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._compute_id, self._imageUploadedCallback, LocalConfig.instance().directFileUpload())
        image_upload_manger.upload()

    def _getQemuBinariesFromServerCallback(self, result, error=False, **kwargs):
@@ -462,25 +554,22 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
            if self.uiQemuListComboBox.count() == 1:
                self.next()
            else:
-                i = self.uiQemuListComboBox.findText(self._appliance["qemu"]["arch"], QtCore.Qt.MatchContains)
+                i = self.uiQemuListComboBox.findData(self._appliance["qemu"]["arch"], flags=QtCore.Qt.MatchEndsWith)
                if i != -1:
                    self.uiQemuListComboBox.setCurrentIndex(i)

    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 as e:
-            QtWidgets.QMessageBox.critical(self.parent(), "Add appliance", str(e))
-            return False
-
        if version is None:
            appliance_configuration = self._appliance.copy()
+            if "docker" not in appliance_configuration:
+                # only Docker do not have version
+                return False
        else:
            try:
                appliance_configuration = self._appliance.search_images_for_version(version)
@@ -488,9 +577,10 @@ 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()
@@ -498,50 +588,72 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
        if "qemu" in appliance_configuration:
            appliance_configuration["qemu"]["path"] = self.uiQemuListComboBox.currentData()

-        worker = WaitForLambdaWorker(
-            lambda: config.add_appliance(appliance_configuration, self._compute_id, self._symbols),
-            allowed_exceptions=[ConfigException, OSError])
+        new_template = ApplianceToTemplate().new_template(appliance_configuration, self._compute_id, self._symbols, parent=self)
+        TemplateManager.instance().createTemplate(Template(new_template), callback=self._templateCreatedCallback)
+        return False

-        progress_dialog = ProgressDialog(worker, "Add appliance", "Install the appliance...", None, busy=True, parent=self)
-        progress_dialog.show()
-        if not progress_dialog.exec_():
-            return False
+        #worker = WaitForLambdaWorker(lambda: self._create_template(appliance_configuration, self._compute_id), allowed_exceptions=[ConfigException, OSError])
+        #progress_dialog = ProgressDialog(worker, "Add template", "Installing a new template...", None, busy=True, parent=self)
+        #progress_dialog.show()
+        #if progress_dialog.exec_():
+        #    QtWidgets.QMessageBox.information(self.parent(), "Add template", "{} template has been installed!".format(appliance_configuration["name"]))
+        #    return True
+        #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
+        # 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):
+    def _templateCreatedCallback(self, result, error=False, **kwargs):
+
+        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 to the compute
+        Upload an image the compute.
        """

-        appliance_configuration = self._appliance.search_images_for_version(version)
+        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
        for image in appliance_configuration["images"]:
            if image["location"] == "local":
+                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
                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()
-
+                image_upload_manager = ImageUploadManager(image, Controller.instance(), self._compute_id, self._applianceImageUploadedCallback, LocalConfig.instance().directFileUpload())
+                image_upload_manager.upload()
                self._image_uploading_count += 1

-    def _applianceImageUploadedCallback(self, result, error=False, **kwargs):
-        self._image_uploading_count -= 1
+    def _applianceImageUploadedCallback(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._image_uploading_count -= 1

    def nextId(self):
        if self.currentPage() == self.uiServerWizardPage:
            if "docker" in self._appliance:
-                return super().nextId() + 3
+                # skip Qemu binary selection and files pages if this is a Docker appliance
+                return super().nextId() + 2
            elif "qemu" not in self._appliance:
-                return super().nextId() + 1
-        elif self.currentPage() == self.uiFilesWizardPage:
-            if "qemu" not in self._appliance:
+                # skip the Qemu binary selection page if not a Qemu appliance
                return super().nextId() + 1
        return super().nextId()

@@ -551,6 +663,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()
@@ -560,20 +674,26 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
            if version is None:
                return False
            appliance = current.data(2, QtCore.Qt.UserRole)
-            if not self._appliance.is_version_installable(version["name"]):
-                QtWidgets.QMessageBox.warning(self, "Appliance", "Sorry, you cannot install {} with missing files".format(appliance["name"]))
+            try:
+                self._appliance.search_images_for_version(version["name"])
+            except ApplianceError as e:
+                QtWidgets.QMessageBox.critical(self, "Appliance", "Cannot install {} version {}: {}".format(appliance["name"], version["name"], e))
                return False
            reply = QtWidgets.QMessageBox.question(self, "Appliance", "Would you like to install {} version {}?".format(appliance["name"], version["name"]),
                                                   QtWidgets.QMessageBox.Yes, QtWidgets.QMessageBox.No)
            if reply == QtWidgets.QMessageBox.No:
                return False
-            self._uploadImages(version["name"])
+
+            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 image uploading")
-                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)
@@ -582,9 +702,11 @@ 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():
@@ -593,20 +715,20 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):
                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:
+            # validate the Qemu
+
+            if self._server_check is False:
+                QtWidgets.QMessageBox.critical(self, "Checking for KVM support", "Please wait for the server to reply...")
+                return False
            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
@@ -616,6 +738,7 @@ class ApplianceWizard(QtWidgets.QWizard, Ui_ApplianceWizard):

        :param checked: either the button is checked or not
        """
+
        if checked:
            self.uiRemoteServersGroupBox.setEnabled(False)
            self.uiRemoteServersGroupBox.hide()
@@ -642,3 +765,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
--- a/gns3/dialogs/configuration_dialog.py
+++ b/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

--- a/gns3/dialogs/console_command_dialog.py
+++ b/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__':
--- a/gns3/dialogs/custom_adapters_configuration_dialog.py
+++ b/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)
--- a/gns3/dialogs/edit_compute_dialog.py
+++ b/gns3/dialogs/edit_compute_dialog.py
@@ -41,6 +41,9 @@ class EditComputeDialog(QtWidgets.QDialog, Ui_EditComputeDialog):
            self.uiServerHostLineEdit.setText(self._compute.host())
            self.uiServerPortSpinBox.setValue(self._compute.port())

+            index = self.uiServerProtocolComboBox.findText(self._compute.protocol().upper())
+            self.uiServerProtocolComboBox.setCurrentIndex(index)
+
            if self._compute.user():
                self.uiEnableAuthenticationCheckBox.setChecked(True)
                self.uiServerUserLineEdit.setText(self._compute.user())
@@ -78,7 +81,7 @@ 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()
--- a/gns3/dialogs/edit_project_dialog.py
+++ b/gns3/dialogs/edit_project_dialog.py
@@ -15,7 +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 QtWidgets
+from ..qt import QtWidgets, QtCore, qslot, qpartial
 from ..topology import Topology
 from ..ui.edit_project_dialog_ui import Ui_EditProjectDialog

@@ -36,6 +36,69 @@ 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.uiNodeGridSizeSpinBox.setValue(self._project.nodeGridSize())
+        self.uiDrawingGridSizeSpinBox.setValue(self._project.drawingGridSize())
+
+        self.uiGlobalVariablesGrid.setAlignment(QtCore.Qt.AlignTop)
+
+        self.uiNewVarButton = QtWidgets.QPushButton('Add new variable', self)
+        self.uiNewVarButton.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed)
+        self.uiNewVarButton.clicked.connect(self.onAddNewVariable)
+        self.uiGlobalVariablesGrid.addWidget(self.uiNewVarButton, 0, 3, QtCore.Qt.AlignRight)
+
+        self._variables = self.setUpVariables()
+        self.updateGlobalVariables()
+
+    def setUpVariables(self):
+        new_variable = {"name": "", "value": ""}
+        variables = self._project.variables()
+
+        if variables is not None:
+            variables.append(new_variable)
+        else:
+            variables = [new_variable]
+        return variables
+
+    def updateGlobalVariables(self):
+        while True:
+            item = self.uiGlobalVariablesGrid.takeAt(1)
+            if item is None:
+                break
+            elif item.widget():
+                item.widget().deleteLater()
+
+        for i, variable in enumerate(self._variables, start=1):
+            nameLabel = QtWidgets.QLabel()
+            nameLabel.setText("Name:")
+            self.uiGlobalVariablesGrid.addWidget(nameLabel, i, 0)
+
+            nameEdit = QtWidgets.QLineEdit()
+            nameEdit.setText(variable.get("name", ""))
+            nameEdit.textChanged.connect(qpartial(self.onNameChange, variable))
+            self.uiGlobalVariablesGrid.addWidget(nameEdit, i, 1)
+
+            valueLabel = QtWidgets.QLabel()
+            valueLabel.setText("Value:")
+            self.uiGlobalVariablesGrid.addWidget(valueLabel, i, 2)
+
+            valueEdit = QtWidgets.QLineEdit()
+            valueEdit.setText(variable.get("value", ""))
+            valueEdit.textChanged.connect(qpartial(self.onValueChange, variable))
+            self.uiGlobalVariablesGrid.addWidget(valueEdit, i, 3)
+
+    @qslot
+    def onAddNewVariable(self, event):
+        self._variables += [{"name": "", "value": ""}]
+        self.updateGlobalVariables()
+
+    def onNameChange(self, variable, text):
+        variable["name"] = text
+
+    def onValueChange(self, variable, text):
+        variable["value"] = text
+
+    def _cleanVariables(self):
+        return [v for v in self._variables if v.get("name").strip() != ""]

    def done(self, result):
        """
@@ -45,11 +108,19 @@ 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.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()
        super().done(result)
--- a/gns3/dialogs/file_editor_dialog.py
+++ b/gns3/dialogs/file_editor_dialog.py
@@ -66,7 +66,7 @@ class FileEditorDialog(QtWidgets.QDialog, Ui_FileEditorDialog):

    def _getCallback(self, result, error=False, raw_body=None, **kwargs):
        if not error:
-            self.uiFileTextEdit.setText(raw_body.decode("utf-8"))
+            self.uiFileTextEdit.setText(raw_body.decode("utf-8", errors="ignore"))
        elif result.get("status") == 404:
            if self._default:
                self.uiFileTextEdit.setText(self._default)
--- a/gns3/dialogs/filter_dialog.py
+++ b/gns3/dialogs/filter_dialog.py
@@ -18,6 +18,9 @@
 from ..qt import QtGui, QtWidgets, qslot
 from ..ui.filter_dialog_ui import Ui_FilterDialog

+import logging
+log = logging.getLogger(__name__)
+

 class FilterDialog(QtWidgets.QDialog, Ui_FilterDialog):

@@ -30,6 +33,7 @@ class FilterDialog(QtWidgets.QDialog, Ui_FilterDialog):
        super().__init__(parent)
        self.setupUi(self)
        self._link = link
+        self._filters = {}
        self._link.updated_link_signal.connect(self._updateUiSlot)
        self._link.listAvailableFilters(self._listAvailableFiltersCallback)
        self._initialized = False
@@ -40,7 +44,7 @@ class FilterDialog(QtWidgets.QDialog, Ui_FilterDialog):

    def _listAvailableFiltersCallback(self, result, error=False, *args, **kwargs):
        if error:
-            QtWidgets.QMessageBox.warning(None, "Link", "Error while listing information about the link: {}".format(result["message"]))
+            log.warning("Error while listing information about the link: {}".format(result["message"]))
            return
        self._filters = result
        self._initialized = True
--- a/gns3/dialogs/idlepc_dialog.py
+++ b/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)
--- a/gns3/dialogs/new_appliance_dialog.py
+++ b/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_()
--- a/gns3/dialogs/new_template_wizard.py
+++ b/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()
--- a/gns3/dialogs/node_info_dialog.py
+++ b/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)
--- a/gns3/dialogs/preferences_dialog.py
+++ b/gns3/dialogs/preferences_dialog.py
@@ -184,10 +184,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 +233,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)
--- a/gns3/dialogs/profile_select.py
+++ b/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__':
--- a/gns3/dialogs/project_dialog.py
+++ b/gns3/dialogs/project_dialog.py
@@ -16,7 +16,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.

 import os
-from ..qt import QtCore, QtGui, QtWidgets, qslot
+from ..qt import QtCore, QtGui, QtWidgets, qslot, sip_is_deleted
 from ..ui.project_dialog_ui import Ui_ProjectDialog
 from ..controller import Controller
 from ..topology import Topology
@@ -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)
@@ -91,6 +91,8 @@ class ProjectDialog(QtWidgets.QDialog, Ui_ProjectDialog):

        projects_to_delete = set()
        for project in self.uiProjectsTreeWidget.selectedItems():
+            if sip_is_deleted(project):
+                continue
            project_id = project.data(0, QtCore.Qt.UserRole)
            project_name = project.data(1, QtCore.Qt.UserRole)

@@ -106,6 +108,7 @@ class ProjectDialog(QtWidgets.QDialog, Ui_ProjectDialog):
            Controller.instance().deleteProject(project_id)

    def _duplicateProjectSlot(self):
+
        if len(self.uiProjectsTreeWidget.selectedItems()) == 0:
            QtWidgets.QMessageBox.critical(self, "Duplicate project", "No project selected")
            return
@@ -132,15 +135,22 @@ 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})
+                                               body={"name": name, "reset_mac_addresses": reset_mac_addresses},
+                                               progressText="Duplicating project '{}'...".format(name),
+                                               timeout=None)
                else:
                    project_location = os.path.join(Topology.instance().projectsDirPath(), name)
                    Controller.instance().post("/projects/{project_id}/duplicate".format(project_id=project_id),
                                               self._duplicateCallback,
-                                               body={"name": name, "path": project_location})
+                                               body={"name": name, "path": project_location, "reset_mac_addresses": reset_mac_addresses},
+                                               progressText="Duplicating project '{}'...".format(name),
+                                               timeout=None)

    def _duplicateCallback(self, result, error=False, **kwargs):
        if error:
@@ -221,20 +231,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:
@@ -268,17 +278,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)

--- a/gns3/dialogs/project_export_wizard.py
+++ b/gns3/dialogs/project_export_wizard.py
@@ -0,0 +1,146 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2018 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import sys
+import os
+import datetime
+
+from gns3.qt import QtCore, QtWidgets
+from ..local_server import LocalServer
+from ..utils.progress_dialog import ProgressDialog
+from ..utils.export_project_worker import ExportProjectWorker
+from ..ui.export_project_wizard_ui import Ui_ExportProjectWizard
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class ExportProjectWizard(QtWidgets.QWizard, Ui_ExportProjectWizard):
+    """
+    Export project wizard.
+    """
+
+    def __init__(self, project, parent):
+
+        super().__init__(parent)
+        self.setupUi(self)
+
+        self._project = project
+        self._path = None
+        self.setWizardStyle(QtWidgets.QWizard.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")
+
+        # set zip compression by default
+        self.uiCompressionComboBox.setCurrentIndex(1)
+        self.helpRequested.connect(self._showHelpSlot)
+        self.uiPathBrowserToolButton.clicked.connect(self._pathBrowserSlot)
+        self._loadReadme()
+
+    def _loadReadme(self):
+
+        self._project.get("/files/README.txt", self._loadedReadme)
+
+    def _loadedReadme(self, result, error=False, raw_body=None, context={}, **kwargs):
+
+        if not error:
+            self.uiReadmeTextEdit.setPlainText(raw_body.decode("utf-8", errors="replace"))
+        else:
+            readme_text = "Project: '{}' created on {}\nAuthor: John Doe <john.doe@example.com>\n\nNo project description was given".format(self._project.name(), datetime.date.today())
+            self.uiReadmeTextEdit.setPlainText(readme_text)
+
+    def _pathBrowserSlot(self):
+
+        directory = QtCore.QStandardPaths.writableLocation(QtCore.QStandardPaths.DocumentsLocation)
+        if len(directory) == 0:
+            directory = LocalServer.instance().localServerSettings()["projects_path"]
+
+        path, _ = QtWidgets.QFileDialog.getSaveFileName(self, "Export portable project", directory,
+                                                        "GNS3 Portable Project (*.gns3project *.gns3p)",
+                                                        "GNS3 Portable Project (*.gns3project *.gns3p)")
+        if path is None or len(path) == 0:
+            return
+
+        self.uiPathLineEdit.setText(path)
+
+    def _showHelpSlot(self):
+
+        include_image_help = """Including base images means additional images will not be requested to
+        import the project on another computer, however the resulting file will be much bigger.
+        Also, you are responsible to check if you have the right to distribute the image(s) as part of the project.
+        """
+        QtWidgets.QMessageBox.information(self, "Help about export a project", include_image_help)
+
+    def validateCurrentPage(self):
+        """
+        Validates if the project can be exported.
+        """
+
+        if self.currentPage() == self.uiExportOptionsWizardPage:
+            path = self.uiPathLineEdit.text().strip()
+            if not path:
+                QtWidgets.QMessageBox.critical(self, "Export project", "Please select a path where to export the project")
+                return False
+
+            if not path.endswith(".gns3project") and not path.endswith(".gns3p"):
+                path += ".gns3project"
+            try:
+                open(path, 'wb+').close()
+            except OSError as e:
+                QtWidgets.QMessageBox.critical(self, "Export project", "Cannot export project to '{}': {}".format(path, e))
+                return False
+            self._path = path
+        elif self.currentPage() == self.uiProjectReadmeWizardPage:
+            text = self.uiReadmeTextEdit.toPlainText().strip()
+            if text:
+                self._project.post("/files/README.txt", self._saveReadmeCallback, body=text)
+        return True
+
+    def _saveReadmeCallback(self, result, error=False, **kwargs):
+        if error:
+            QtWidgets.QMessageBox.critical(self, "Export project", "Could not created readme file")
+
+    def done(self, result):
+        """
+        This dialog is closed.
+        """
+
+        if result:
+            if self.uiIncludeImagesCheckBox.isChecked():
+                include_images = "yes"
+            else:
+                include_images = "no"
+            if self.uiIncludeSnapshotsCheckBox.isChecked():
+                include_snapshots = "yes"
+            else:
+                include_snapshots = "no"
+            if self.uiResetMacAddressesCheckBox.isChecked():
+                reset_mac_addresses = "yes"
+            else:
+                reset_mac_addresses = "no"
+            compression = self.uiCompressionComboBox.currentData()
+            export_worker = ExportProjectWorker(self._project, self._path, include_images, include_snapshots, reset_mac_addresses, compression)
+            progress_dialog = ProgressDialog(export_worker, "Exporting project", "Exporting portable project files...", "Cancel", parent=self, create_thread=False)
+            progress_dialog.show()
+            progress_dialog.exec_()
+        super().done(result)
--- a/gns3/dialogs/project_welcome_dialog.py
+++ b/gns3/dialogs/project_welcome_dialog.py
@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2018 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import copy
+
+from gns3.qt import QtWidgets, QtCore, qpartial
+from gns3.ui.project_welcome_dialog_ui import Ui_ProjectWelcomeDialog
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class ProjectWelcomeDialog(QtWidgets.QDialog, Ui_ProjectWelcomeDialog):
+    """
+    This dialog shows when project is imported and global variables assigned to the project are missing.
+    """
+
+    def __init__(self, parent, project):
+
+        super().__init__(parent)
+        self._project = project
+        self.setupUi(self)
+        self.uiOkButton.clicked.connect(self._okButtonClickedSlot)
+        self.gridLayout.setAlignment(QtCore.Qt.AlignTop)
+        self.label.setOpenExternalLinks(True)
+        self._variables = self._getVariables(project)
+        self._loadReadme()
+        self._addMisingVariablesEdits()
+
+    def _getVariables(self, project):
+        variables = copy.copy(self._project.variables())
+        if variables is None:
+            variables = []
+        return variables
+
+    def _addMisingVariablesEdits(self):
+        #TODO: refactor this to use a QListWidget
+        missing = [v for v in self._variables if v.get("name") and v.get("value", "").strip() == ""]
+        for i, variable in enumerate(missing, start=0):
+            nameLabel = QtWidgets.QLabel()
+            nameLabel.setText(variable.get("name") + ":")
+            self.gridLayout.addWidget(nameLabel, i, 0)
+
+            valueEdit = QtWidgets.QLineEdit()
+            valueEdit.setText(variable.get("value", ""))
+            valueEdit.textChanged.connect(qpartial(self.onValueChange, variable))
+            self.gridLayout.addWidget(valueEdit, i, 1)
+
+    def _loadReadme(self):
+        self._project.get("/files/README.txt", self._loadedReadme)
+
+    def _loadedReadme(self, result, error=False, raw_body=None, context={}, **kwargs):
+        if not error:
+            self.label.setText(raw_body.decode("utf-8"))
+
+    def onValueChange(self, variable, text):
+        variable["value"] = text
+
+    def _okButtonClickedSlot(self):
+        missing = [v for v in self._variables if v.get("name") and v.get("value", "").strip() == ""]
+        if len(missing) > 0:
+            reply = QtWidgets.QMessageBox.warning(self,
+                                                  "Missing values",
+                                                  "Are you sure you want to continue without providing missing values?",
+                                                  QtWidgets.QMessageBox.Yes,
+                                                  QtWidgets.QMessageBox.No)
+            if reply == QtWidgets.QMessageBox.No:
+                return
+
+        self._project.setVariables(self._variables)
+        self._project.update()
+        self.accept()
+
--- a/gns3/dialogs/setup_wizard.py
+++ b/gns3/dialogs/setup_wizard.py
@@ -22,8 +22,7 @@ import shutil
 from gns3.qt import QtCore, QtWidgets, QtGui, QtNetwork, qslot
 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 gns3.utils.interfaces import interfaces

 from ..settings import DEFAULT_LOCAL_SERVER_HOST
 from ..ui.setup_wizard_ui import Ui_SetupWizard
@@ -44,15 +43,18 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):

        super().__init__(parent)
        self.setupUi(self)
+        self.adjustSize()

        self._gns3_vm_settings = {
            "enable": True,
            "headless": False,
            "when_exit": "stop",
            "engine": "vmware",
+            "allocate_vcpus_ram": True,
            "vcpus": 1,
            "ram": 2048,
-            "vmname": "GNS3 VM"
+            "vmname": "GNS3 VM",
+            "port": 80
        }

        self.setWizardStyle(QtWidgets.QWizard.ModernStyle)
@@ -62,11 +64,10 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):

        self.uiLocalServerToolButton.clicked.connect(self._localServerBrowserSlot)

-        self.uiGNS3VMDownloadLinkUrlLabel.setText('')
+        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"])

@@ -81,20 +82,21 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):

        # 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)
+            self.uiLocalLabel.setText("Dependencies like Dynamips and Qemu must be manually installed")

        Controller.instance().connected_signal.connect(self._refreshLocalServerStatusSlot)
        Controller.instance().connection_failed_signal.connect(self._refreshLocalServerStatusSlot)
@@ -114,13 +116,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/621394/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.
@@ -141,7 +136,6 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
        Slot to refresh the VirtualBox VMs list.
        """

-        QtWidgets.QMessageBox.warning(self, "GNS3 VM on VirtualBox", "VirtualBox doesn't support nested virtualization, this means running Qemu based VM could be very slow")
        download_url = "https://github.com/GNS3/gns3-gui/releases/download/v{version}/GNS3.VM.VirtualBox.{version}.zip".format(version=__version__)
        self.uiGNS3VMDownloadLinkUrlLabel.setText('If you don\'t have the GNS3 Virtual Machine you can <a href="{download_url}">download it here</a>.<br>And import the VM in the virtualization software and hit refresh.'.format(download_url=download_url))
        self.uiVmwareRadioButton.setChecked(False)
@@ -201,6 +195,19 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
            index = self.uiLocalServerHostComboBox.findData(local_server_settings["host"])
            if index != -1:
                self.uiLocalServerHostComboBox.setCurrentIndex(index)
+            else:
+                if self.uiVMRadioButton.isChecked():
+                    # Try to bind with the IP address allocated for VMnet1
+                    for interface in interfaces():
+                        if "vmnet1" in interface["name"].lower():
+                            index = self.uiLocalServerHostComboBox.findText(interface["ip_address"])
+                            break
+                else:
+                    index = self.uiLocalServerHostComboBox.findText(DEFAULT_LOCAL_SERVER_HOST)
+
+                if index != -1:
+                    self.uiLocalServerHostComboBox.setCurrentIndex(index)
+
            self.uiLocalServerPortSpinBox.setValue(local_server_settings["port"])

        elif self.page(page_id) == self.uiRemoteControllerWizardPage:
@@ -245,14 +252,16 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
        """
        Refresh the local server status page
        """
+
+        self.uiLocalServerTextEdit.clear()
        if Controller.instance().connected():
-            self.uiLocalServerStatusLabel.setText("Connection to local server successful")
+            self.uiLocalServerTextEdit.setText("Connection to the local GNS3 server has been successful!")
            Controller.instance().get("/gns3vm", self._getSettingsCallback)
        elif Controller.instance().connecting():
-            self.uiLocalServerStatusLabel.setText("Please wait connection to the GNS3 server")
+            self.uiLocalServerTextEdit.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"]))
+            self.uiLocalServerTextEdit.setText("Connection to local server failed. Please try one of the following:\n\n- Make sure GNS3 is allowed to run by your firewall.\n- Go back and try to change the server host binding and/or the port\n- Check with a browser if you can connect to {protocol}://{host}:{port}.\n- Try to run {path} in a terminal to see if you have an error.".format(protocol=local_server_settings["protocol"], host=local_server_settings["host"], port=local_server_settings["port"], path=local_server_settings["path"]))

    def _GNS3VMSettings(self):
        return self._gns3_vm_settings
@@ -263,7 +272,7 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
    def _saveSettingsCallback(self, result, error=False, **kwargs):
        if error:
            if "message" in result:
-                QtWidgets.QMessageBox.critical(self, "Save settings", "Error while save settings: {}".format(result["message"]))
+                QtWidgets.QMessageBox.critical(self, "Save settings", "Error while saving settings: {}".format(result["message"]))
            return

    def _addSummaryEntry(self, name, value):
@@ -323,7 +332,8 @@ class SetupWizard(QtWidgets.QWizard, Ui_SetupWizard):
                return False

            LocalServer.instance().updateLocalServerSettings(local_server_settings)
-            LocalServer.instance().localServerAutoStartIfRequire()
+            if not LocalServer.instance().localServerAutoStartIfRequired():
+                return False

        elif self.currentPage() == self.uiRemoteControllerWizardPage:
            local_server_settings = LocalServer.instance().localServerSettings()
@@ -398,11 +408,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)

--- a/gns3/dialogs/snapshots_dialog.py
+++ b/gns3/dialogs/snapshots_dialog.py
@@ -22,8 +22,6 @@ Dialog to manage the snapshots.
 from ..qt import QtCore, QtWidgets
 from ..ui.snapshots_dialog_ui import Ui_SnapshotsDialog
 from ..controller import Controller
-from ..utils.progress_dialog import ProgressDialog
-from ..utils.create_snapshot_worker import CreateSnapshotWorker

 from datetime import datetime

@@ -87,21 +85,21 @@ 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:
-            snapshot_worker = CreateSnapshotWorker(self._project, snapshot_name)
-            snapshot_worker.finished.connect(self._createSnapshotsCallback)
+            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)

-            progress_dialog = ProgressDialog(snapshot_worker, "Snapshot progress", "Creation of snapshot in progress...",
-                                             "Cancel", busy=True, parent=self, create_thread=False, cancelable=True)
-            progress_dialog.show()
-            progress_dialog.exec_()
-
-
-    def _createSnapshotsCallback(self):
+    def _createSnapshotsCallback(self, result, error=False, server=None, context={}, **kwargs):
+        if error:
+            if result:
+                log.error(result["message"])
+            else:
+                log.error("Cannot create snapshot of project")
+            return
        self._listSnapshots()

-    def _createSnapshotsErrorCallback(self, message, error):
-        log.error(message)
-
    def _deleteSnapshotSlot(self):
        """
        Slot to delete a snapshot.
@@ -113,6 +111,7 @@ class SnapshotsDialog(QtWidgets.QDialog, Ui_SnapshotsDialog):
            Controller.instance().delete("/projects/{}/snapshots/{}".format(self._project.id(), snapshot_id), self._deleteSnapshotsCallback)

    def _deleteSnapshotsCallback(self, result, error=False, server=None, context={}, **kwargs):
+
        if error:
            if result:
                log.error(result["message"])
@@ -135,13 +134,16 @@ class SnapshotsDialog(QtWidgets.QDialog, Ui_SnapshotsDialog):

        :param snapshot_id: id of the snapshot
        """
-        reply = QtWidgets.QMessageBox.question(self, "Snapshots", "This will discard any changes made to your project since the snapshot was taken?", QtWidgets.QMessageBox.Ok, QtWidgets.QMessageBox.Cancel)
+
+        reply = QtWidgets.QMessageBox.question(self, "Snapshots", "This will discard any changes made to your project since the snapshot was taken, would you like to proceed?", QtWidgets.QMessageBox.Ok, QtWidgets.QMessageBox.Cancel)
        if reply == QtWidgets.QMessageBox.Cancel:
            return

-        Controller.instance().post("/projects/{}/snapshots/{}/restore".format(self._project.id(), snapshot_id), self._restoreSnapshotsCallback, timeout=300)
+        Controller.instance().post("/projects/{}/snapshots/{}/restore".format(self._project.id(), snapshot_id),
+                                   self._restoreSnapshotsCallback, progressText="Restoring snapshot...", timeout=None)

    def _restoreSnapshotsCallback(self, result, error=False, server=None, context={}, **kwargs):
+
        if error:
            if result:
                log.error(result["message"])
--- a/gns3/dialogs/style_editor_dialog_link.py
+++ b/gns3/dialogs/style_editor_dialog_link.py
@@ -0,0 +1,115 @@
+# -*- 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.uiRotationLabel.hide()
+        self.uiRotationSpinBox.hide()
+
+        pen = link.pen()
+
+        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)
+
+    def done(self, result):
+        """
+        Called when the dialog is closed.
+
+        :param result: boolean (accepted or rejected)
+        """
+
+        if result:
+            self._applyPreferencesSlot()
+        super().done(result)
--- a/gns3/dialogs/symbol_selection_dialog.py
+++ b/gns3/dialogs/symbol_selection_dialog.py
@@ -22,10 +22,9 @@ Dialog to change node symbols.
 import os
 import pathlib

-from ..qt import QtCore, QtGui, QtWidgets, qpartial
+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,9 +62,10 @@ 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().get("/symbols", self._listSymbolsCallback)

@@ -78,33 +77,39 @@ 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):
+                    return
                svg_renderer = QImageSvgRenderer(path)
                image = QtGui.QImage(64, 64, QtGui.QImage.Format_ARGB32)
                # Set the ARGB to 0 to prevent rendering artifacts
                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()
-
    def _searchTextChangedSlot(self, text):
        self._filter()

@@ -114,10 +119,10 @@ 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():
+            if not item.data(0, QtCore.Qt.UserRole).builtin():
                item.setHidden(True)
            else:
-                if len(text.strip()) == 0 or text.strip().lower() in item.text().lower():
+                if len(text.strip()) == 0 or text.strip().lower() in item.text(0).lower():
                    item.setHidden(False)
                else:
                    item.setHidden(True)
@@ -156,16 +161,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
@@ -184,7 +191,7 @@ class SymbolSelectionDialog(QtWidgets.QDialog, Ui_SymbolSelectionDialog):

    def _finishSymbolUpload(self, path, result, error=False, **kwargs):
        if error:
-            log.error("Error while uploading symbol: {}".format(path))
+            log.error("Error while uploading symbol: {}: {}".format(path, result.get("message", "unknown")))
            return
        self.uiSymbolLineEdit.clear()
        self.uiSymbolLineEdit.setText(path)
--- a/gns3/dialogs/text_editor_dialog.py
+++ b/gns3/dialogs/text_editor_dialog.py
@@ -19,7 +19,7 @@
 Text editor to edit Note items.
 """

-from ..qt import QtCore, QtWidgets, qslot
+from ..qt import QtCore, QtWidgets, qslot, sip_is_deleted
 from ..ui.text_editor_dialog_ui import Ui_TextEditorDialog


@@ -98,6 +98,8 @@ class TextEditorDialog(QtWidgets.QDialog, Ui_TextEditorDialog):
        """

        for item in self._items:
+            if sip_is_deleted(item):
+                continue
            item.setFont(self.uiPlainTextEdit.font())
            if self.uiApplyColorToAllItemsCheckBox.isChecked():
                item.setDefaultTextColor(self._color)
--- a/gns3/dialogs/vm_with_images_wizard.py
+++ b/gns3/dialogs/vm_with_images_wizard.py
@@ -88,7 +88,7 @@ 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)
+        create_dialog = create_image_wizard(self, self.getSettings()["compute_id"], self.uiNameLineEdit.text() + image_suffix)
        if QtWidgets.QDialog.Accepted == create_dialog.exec_():
            line_edit.setText(create_dialog.uiLocationLineEdit.text())

--- a/gns3/graphics_view.py
+++ b/gns3/graphics_view.py
@@ -21,7 +21,7 @@ Graphical view on the scene where items are drawn.

 import logging
 import os
-import sip
+from .qt import sip
 import sys

 from .qt import QtCore, QtGui, QtNetwork, QtWidgets, qpartial, qslot
@@ -34,25 +34,27 @@ from .modules.module_error import ModuleError
 from .modules.builtin import Builtin
 from .settings import GRAPHICS_VIEW_SETTINGS
 from .topology import Topology
-from .appliance_manager import ApplianceManager
+from .template_manager import TemplateManager
 from .dialogs.style_editor_dialog import StyleEditorDialog
 from .dialogs.text_editor_dialog import TextEditorDialog
 from .dialogs.symbol_selection_dialog import SymbolSelectionDialog
 from .dialogs.idlepc_dialog import IdlePCDialog
 from .dialogs.console_command_dialog import ConsoleCommandDialog
 from .dialogs.file_editor_dialog import FileEditorDialog
+from .dialogs.node_info_dialog import NodeInfoDialog
 from .local_config import LocalConfig
 from .progress import Progress
 from .utils.server_select import server_select
 from .compute_manager import ComputeManager
+from .utils.get_icon import get_icon

 # link items
-from .items.link_item import LinkItem
+from .items.link_item import LinkItem, SvgIconItem
 from .items.ethernet_link_item import EthernetLinkItem
 from .items.serial_link_item import SerialLinkItem

 # other items
-from .items.note_item import NoteItem
+from .items.label_item import LabelItem
 from .items.text_item import TextItem
 from .items.shape_item import ShapeItem
 from .items.drawing_item import DrawingItem
@@ -60,12 +62,12 @@ from .items.rectangle_item import RectangleItem
 from .items.line_item import LineItem
 from .items.ellipse_item import EllipseItem
 from .items.image_item import ImageItem
+from .items.logo_item import  LogoItem

 log = logging.getLogger(__name__)


 class GraphicsView(QtWidgets.QGraphicsView):
-
    """
    Graphics view that displays the scene.

@@ -88,6 +90,8 @@ class GraphicsView(QtWidgets.QGraphicsView):
        self._adding_line = False
        self._newlink = None
        self._dragging = False
+        self._grid_size = 75
+        self._drawing_grid_size = 25
        self._last_mouse_position = None
        self._topology = Topology.instance()
        self._background_warning_msgbox = QtWidgets.QErrorMessage(self)
@@ -107,11 +111,8 @@ class GraphicsView(QtWidgets.QGraphicsView):
        self.setResizeAnchor(QtWidgets.QGraphicsView.AnchorViewCenter)

        # default directories for QFileDialog
-        self._import_configs_from_dir = QtCore.QStandardPaths.writableLocation(QtCore.QStandardPaths.DocumentsLocation)
-        self._import_config_dir = ""
-        self._export_configs_to_dir = QtCore.QStandardPaths.writableLocation(QtCore.QStandardPaths.DocumentsLocation)
-        self._export_config_dir = ""
-
+        self._import_config_directory = QtCore.QStandardPaths.writableLocation(QtCore.QStandardPaths.DocumentsLocation)
+        self._export_config_directory = QtCore.QStandardPaths.writableLocation(QtCore.QStandardPaths.DocumentsLocation)
        self._local_addresses = ['0.0.0.0', '127.0.0.1', 'localhost', '::1', '0:0:0:0:0:0:0:1', '::', QtNetwork.QHostInfo.localHostName()]

    def setSceneSize(self, width, height):
@@ -127,6 +128,32 @@ class GraphicsView(QtWidgets.QGraphicsView):
            factor = zoom / 100.
            self.scale(factor, factor)

+    def setNodeGridSize(self, grid_size):
+        """
+        Sets the grid size for nodes.
+        """
+        self._grid_size = grid_size
+
+    def nodeGridSize(self):
+        """
+        Returns the grid size for nodes.
+        :return: integer
+        """
+        return self._grid_size
+
+    def setDrawingGridSize(self, grid_size):
+        """
+        Sets the grid size for drawings
+        """
+        self._drawing_grid_size = grid_size
+
+    def drawingGridSize(self):
+        """
+        Returns the grid size for drawings
+        :return: integer
+        """
+        return self._drawing_grid_size
+
    def setEnabled(self, enabled):

        if enabled is False:
@@ -160,9 +187,13 @@ class GraphicsView(QtWidgets.QGraphicsView):
        # clear the topology summary
        self._main_window.uiTopologySummaryTreeWidget.clear()

+        # reset the lock button
+        self._main_window.uiLockAllAction.setChecked(False)
+
        # clear all objects on the scene
        self.scene().clear()

+
    def _loadSettings(self):
        """
        Loads the settings from the persistent settings file.
@@ -275,6 +306,10 @@ class GraphicsView(QtWidgets.QGraphicsView):
        self.scene().addItem(image_item)
        self._topology.addDrawing(image_item)

+    def addLogo(self, logo_path, logo_url):
+        logo_item = LogoItem(logo_path, logo_url, self._topology.project())
+        self.scene().addItem(logo_item)
+
    def addLink(self, source_node, source_port, destination_node, destination_port, **link_data):
        """
        Creates a Link instance representing a connection between 2 devices.
@@ -357,7 +392,7 @@ class GraphicsView(QtWidgets.QGraphicsView):
        # link addition code
        if not self._newlink:
            source_item = item
-            source_port = source_item.connectToPort()
+            source_port = source_item.connectToPort(event.globalPos())
            if not source_port:
                return

@@ -374,7 +409,7 @@ class GraphicsView(QtWidgets.QGraphicsView):
            source_item = self._newlink.sourceItem()
            source_port = self._newlink.sourcePort()
            destination_item = item
-            destination_port = destination_item.connectToPort()
+            destination_port = destination_item.connectToPort(event.globalPos())
            if not destination_port:
                return

@@ -395,12 +430,16 @@ class GraphicsView(QtWidgets.QGraphicsView):
        """

        is_not_link = True
+        is_not_logo = True
+
        item = self.itemAt(event.pos())
        if item and sip.isdeleted(item):
            return

        if item and (isinstance(item, LinkItem) or isinstance(item.parentItem(), LinkItem)):
            is_not_link = False
+        if item and (isinstance(item, LogoItem) or isinstance(item.parentItem(), LogoItem)):
+            is_not_logo = False
        else:
            for it in self.scene().items():
                if isinstance(it, LinkItem):
@@ -420,34 +459,19 @@ class GraphicsView(QtWidgets.QGraphicsView):
                item.setSelected(False)
            else:
                item.setSelected(True)
-        elif is_not_link and event.button() == QtCore.Qt.RightButton and not self._adding_link:
-            if item and not sip.isdeleted(item):
-                # Prevent right clicking on a selected item from de-selecting all other items
-                if not item.isSelected():
-                    if not event.modifiers() & QtCore.Qt.ControlModifier:
-                        for it in self.scene().items():
-                            it.setSelected(False)
-                    if item.zValue() < 0:
-                        item.setFlag(item.ItemIsSelectable, True)
-                    item.setSelected(True)
-                    self._showDeviceContextualMenu(QtGui.QCursor.pos())
-                    if not sip.isdeleted(item) and item.zValue() < 0:
-                        item.setFlag(item.ItemIsSelectable, False)
-
-                else:
-                    self._showDeviceContextualMenu(QtGui.QCursor.pos())
-            # when more than one item is selected display the contextual menu even if mouse is not above an item
-            elif len(self.scene().selectedItems()) > 1:
-                self._showDeviceContextualMenu(QtGui.QCursor.pos())
+        elif is_not_link and is_not_logo and event.button() == QtCore.Qt.RightButton and not self._adding_link:
+            pass #TODO: remove this without creating a bug...
        elif is_not_link and self._adding_link and event.button() == QtCore.Qt.RightButton:
            # send a escape key to the main window to cancel the link addition
            key = QtGui.QKeyEvent(QtCore.QEvent.KeyPress, QtCore.Qt.Key_Escape, QtCore.Qt.NoModifier)
            QtWidgets.QApplication.sendEvent(self._main_window, key)
        elif item and isinstance(item, NodeItem) and self._adding_link and event.button() == QtCore.Qt.LeftButton:
            self._userNodeLinking(event, item)
+            #context_event = QtGui.QContextMenuEvent(QtGui.QContextMenuEvent.Mouse, event.pos())
+            #QtWidgets.QApplication.sendEvent(self, context_event)
        elif event.button() == QtCore.Qt.LeftButton and self._adding_note:
            pos = self.mapToScene(event.pos())
-            note = self.createDrawingItem("text", pos.x(), pos.y(), 1)
+            note = self.createDrawingItem("text", pos.x(), pos.y(), 2)
            pos_x = note.pos().x()
            pos_y = note.pos().y() - (note.boundingRect().height() / 2)
            note.setPos(pos_x, pos_y)
@@ -457,19 +481,19 @@ class GraphicsView(QtWidgets.QGraphicsView):
            self._adding_note = False
        elif event.button() == QtCore.Qt.LeftButton and self._adding_rectangle:
            pos = self.mapToScene(event.pos())
-            self.createDrawingItem("rect", pos.x(), pos.y(), 0)
+            self.createDrawingItem("rect", pos.x(), pos.y(), 1)
            self._main_window.uiDrawRectangleAction.setChecked(False)
            self.setCursor(QtCore.Qt.ArrowCursor)
            self._adding_rectangle = False
        elif event.button() == QtCore.Qt.LeftButton and self._adding_ellipse:
            pos = self.mapToScene(event.pos())
-            self.createDrawingItem("ellipse", pos.x(), pos.y(), 0)
+            self.createDrawingItem("ellipse", pos.x(), pos.y(), 1)
            self._main_window.uiDrawEllipseAction.setChecked(False)
            self.setCursor(QtCore.Qt.ArrowCursor)
            self._adding_ellipse = False
        elif event.button() == QtCore.Qt.LeftButton and self._adding_line:
            pos = self.mapToScene(event.pos())
-            self.createDrawingItem("line", pos.x(), pos.y(), 0)
+            self.createDrawingItem("line", pos.x(), pos.y(), 1)
            self._main_window.uiDrawLineAction.setChecked(False)
            self.setCursor(QtCore.Qt.ArrowCursor)
            self._adding_line = False
@@ -478,6 +502,46 @@ class GraphicsView(QtWidgets.QGraphicsView):

        self.toggleUiDeviceMenu()

+    def contextMenuEvent(self, event):
+        """
+        Handles all context menu events.
+
+        :param event: QContextMenuEvent instance
+        """
+
+        is_not_link = True
+        is_not_logo = True
+
+        item = self.itemAt(event.pos())
+        if item and sip.isdeleted(item):
+            return
+
+        if item and (isinstance(item, LinkItem) or isinstance(item.parentItem(), LinkItem)):
+            is_not_link = False
+        if item and (isinstance(item, LogoItem) or isinstance(item.parentItem(), LogoItem)):
+            is_not_logo = False
+        else:
+            for it in self.scene().items():
+                if isinstance(it, LinkItem):
+                    it.setHovered(False)
+
+        if is_not_link and is_not_logo and not self._adding_link:
+            if item and not sip.isdeleted(item):
+                # Prevent right clicking on a selected item from de-selecting all other items
+                if not item.isSelected():
+                    if not event.modifiers() & QtCore.Qt.ControlModifier:
+                        for it in self.scene().items():
+                            it.setSelected(False)
+                    item.setSelected(True)
+                self._showDeviceContextualMenu(event.globalPos())
+            # when more than one item is selected display the contextual menu even if mouse is not above an item
+            elif len(self.scene().selectedItems()) > 1:
+                self._showDeviceContextualMenu(event.globalPos())
+        #elif item and isinstance(item, NodeItem) and self._adding_link:
+        #    self._userNodeLinking(event, item)
+        else:
+            super().contextMenuEvent(event)
+
    def mouseReleaseEvent(self, event):
        """
        Handles all mouse release events.
@@ -513,7 +577,7 @@ class GraphicsView(QtWidgets.QGraphicsView):
            delta = event.angleDelta()
            if delta is not None and delta.x() == 0:
                # CTRL is pressed then use the mouse wheel to zoom in or out.
-                self.scaleView(pow(2.0, delta.y() / 240.0))
+                self.scaleView(pow(2.0, (delta.y()/2) / 240.0))
                self._topology.project().setZoom(round(self.transform().m11() * 100))
                self._topology.project().update()
        else:
@@ -538,9 +602,9 @@ class GraphicsView(QtWidgets.QGraphicsView):
        """

        if event.key() == QtCore.Qt.Key_Delete:
-            # check if we are editing an NoteItem instance, then send the delete key event to it
+            # check if we are editing an LabelItem instance, then send the delete key event to it
            for item in self.scene().selectedItems():
-                if (isinstance(item, NoteItem) or isinstance(item, TextItem)) and item.hasFocus():
+                if (isinstance(item, LabelItem) or isinstance(item, TextItem)) and item.hasFocus():
                    super().keyPressEvent(event)
                    return
            self.deleteActionSlot()
@@ -593,7 +657,7 @@ class GraphicsView(QtWidgets.QGraphicsView):
        if not self._adding_link:
            if isinstance(item, NodeItem) and item.node().initialized():
                item.setSelected(True)
-                if item.node().status() == Node.stopped or item.node().isAlwaysOn():
+                if item.node().status() == Node.stopped or item.node().consoleType() == "none":
                    self.configureSlot()
                    return
                else:
@@ -601,7 +665,7 @@ class GraphicsView(QtWidgets.QGraphicsView):
                        return
                    self.consoleFromItems(self.scene().selectedItems())
                    return
-            elif isinstance(item, NoteItem) and isinstance(item.parentItem(), NodeItem):
+            elif isinstance(item, LabelItem) and isinstance(item.parentItem(), NodeItem):
                if item.parentItem().node().initialized():
                    item.parentItem().setSelected(True)
                    self.changeHostnameActionSlot()
@@ -633,7 +697,7 @@ class GraphicsView(QtWidgets.QGraphicsView):

        # check if what is dragged is handled by this view
        if event.mimeData().hasFormat("text/uri-list") \
-                or event.mimeData().hasFormat("application/x-gns3-appliance"):
+                or event.mimeData().hasFormat("application/x-gns3-template"):
            event.acceptProposedAction()
            event.accept()
        else:
@@ -647,8 +711,8 @@ class GraphicsView(QtWidgets.QGraphicsView):
        """

        # check if what has been dropped is handled by this view
-        if event.mimeData().hasFormat("application/x-gns3-appliance"):
-            appliance_id = event.mimeData().data("application/x-gns3-appliance").data().decode()
+        if event.mimeData().hasFormat("application/x-gns3-template"):
+            template_id = event.mimeData().data("application/x-gns3-template").data().decode()
            event.setDropAction(QtCore.Qt.CopyAction)
            event.accept()
            if event.keyboardModifiers() == QtCore.Qt.ShiftModifier:
@@ -659,11 +723,11 @@ class GraphicsView(QtWidgets.QGraphicsView):
                    for node_number in range(integer):
                        x = event.pos().x() - (150 / 2) + (node_number % max_nodes_per_line) * offset
                        y = event.pos().y() - (70 / 2) + (node_number // max_nodes_per_line) * offset
-                        if self.createNodeFromApplianceId(appliance_id, QtCore.QPoint(x, y)) is False:
+                        if self.createNodeFromTemplateId(template_id, QtCore.QPoint(x, y)) is False:
                            event.ignore()
                            break
            else:
-                if self.createNodeFromApplianceId(appliance_id, event.pos()) is False:
+                if self.createNodeFromTemplateId(template_id, event.pos()) is False:
                    event.ignore()
        elif event.mimeData().hasFormat("text/uri-list") and event.mimeData().hasUrls():
            # This should not arrive but we received bug report with it...
@@ -690,6 +754,11 @@ class GraphicsView(QtWidgets.QGraphicsView):
        self.populateDeviceContextualMenu(menu)
        menu.exec_(pos)
        menu.clear()
+        # Make sure to deselect all items.
+        # This is to prevent a bug on Windows
+        # see https://github.com/GNS3/gns3-gui/issues/2986
+        for it in self.scene().items():
+            it.setSelected(False)

    def populateDeviceContextualMenu(self, menu):
        """
@@ -703,146 +772,147 @@ class GraphicsView(QtWidgets.QGraphicsView):
            return

        if True in list(map(lambda item: isinstance(item, NodeItem) and hasattr(item.node(), "configPage"), items)):
+            # Action: Configure node
            configure_action = QtWidgets.QAction("Configure", menu)
-            configure_action.setIcon(QtGui.QIcon(':/icons/configuration.svg'))
+            configure_action.setIcon(get_icon("configuration.svg"))
            configure_action.triggered.connect(self.configureActionSlot)
            menu.addAction(configure_action)

+        if True in list(map(lambda item: isinstance(item, NodeItem) and item.node().console() is not None, items)):
+            console_action = QtWidgets.QAction("Console", menu)
+            console_action.setIcon(get_icon("console.svg"))
+            console_action.triggered.connect(self.consoleActionSlot)
+            menu.addAction(console_action)
+
+        if True in list(map(lambda item: isinstance(item, NodeItem) and hasattr(item.node(), "auxConsole"), items)):
+            aux_console_action = QtWidgets.QAction("Auxiliary console", menu)
+            aux_console_action.setIcon(get_icon("aux-console.svg"))
+            aux_console_action.triggered.connect(self.auxConsoleActionSlot)
+            menu.addAction(aux_console_action)
+
+        if True in list(map(lambda item: isinstance(item, NodeItem) and not item.node().isAlwaysOn(), items)):
+            start_action = QtWidgets.QAction("Start", menu)
+            start_action.setIcon(get_icon("start.svg"))
+            start_action.triggered.connect(self.startActionSlot)
+            menu.addAction(start_action)
+
+        if True in list(map(lambda item: isinstance(item, NodeItem) and not item.node().isAlwaysOn(), items)):
+            suspend_action = QtWidgets.QAction("Suspend", menu)
+            suspend_action.setIcon(get_icon("pause.svg"))
+            suspend_action.triggered.connect(self.suspendActionSlot)
+            menu.addAction(suspend_action)
+
+        if True in list(map(lambda item: isinstance(item, NodeItem) and not item.node().isAlwaysOn(), items)):
+            stop_action = QtWidgets.QAction("Stop", menu)
+            stop_action.setIcon(get_icon("stop.svg"))
+            stop_action.triggered.connect(self.stopActionSlot)
+            menu.addAction(stop_action)
+
+        if True in list(map(lambda item: isinstance(item, NodeItem) and not item.node().isAlwaysOn(), items)):
+            reload_action = QtWidgets.QAction("Reload", menu)
+            reload_action.setIcon(get_icon("reload.svg"))
+            reload_action.triggered.connect(self.reloadActionSlot)
+            menu.addAction(reload_action)
+
+        if True in list(map(lambda item: isinstance(item, NodeItem) and item.node().console() is not None, items)):
+            console_edit_action = QtWidgets.QAction("Custom console", menu)
+            console_edit_action.setIcon(get_icon("console_edit.svg"))
+            console_edit_action.triggered.connect(self.customConsoleActionSlot)
+            menu.addAction(console_edit_action)
+
        if True in list(map(lambda item: isinstance(item, NodeItem), items)):
            # Action: Change hostname
            change_hostname_action = QtWidgets.QAction("Change hostname", menu)
-            change_hostname_action.setIcon(QtGui.QIcon(':/icons/show-hostname.svg'))
+            change_hostname_action.setIcon(get_icon("show-hostname.svg"))
            change_hostname_action.triggered.connect(self.changeHostnameActionSlot)
            menu.addAction(change_hostname_action)

        if True in list(map(lambda item: isinstance(item, NodeItem), items)):
            # Action: Change symbol
            change_symbol_action = QtWidgets.QAction("Change symbol", menu)
-            change_symbol_action.setIcon(QtGui.QIcon(':/icons/node_conception.svg'))
+            change_symbol_action.setIcon(get_icon("node_conception.svg"))
            change_symbol_action.triggered.connect(self.changeSymbolActionSlot)
            menu.addAction(change_symbol_action)

        if True in list(map(lambda item: isinstance(item, DrawingItem) or isinstance(item, NodeItem), items)):
            duplicate_action = QtWidgets.QAction("Duplicate", menu)
-            duplicate_action.setIcon(QtGui.QIcon(':/icons/new.svg'))
+            duplicate_action.setIcon(get_icon("duplicate.svg"))
            duplicate_action.triggered.connect(self.duplicateActionSlot)
            menu.addAction(duplicate_action)

+        if True in list(map(lambda item: isinstance(item, NodeItem) and hasattr(item.node(), "info"), items)):
+            # Action: Show node information
+            show_node_info_action = QtWidgets.QAction("Show node information", menu)
+            show_node_info_action.setIcon(get_icon("help.svg"))
+            show_node_info_action.triggered.connect(self.showNodeInfoSlot)
+            menu.addAction(show_node_info_action)
+
        if True in list(map(lambda item: isinstance(item, NodeItem) and hasattr(item.node(), "nodeDir"), items)):
            # Action: Show in file manager
            show_in_file_manager_action = QtWidgets.QAction("Show in file manager", menu)
-            show_in_file_manager_action.setIcon(QtGui.QIcon(':/icons/open.svg'))
+            show_in_file_manager_action.setIcon(get_icon("open.svg"))
            show_in_file_manager_action.triggered.connect(self.showInFileManagerSlot)
            menu.addAction(show_in_file_manager_action)

-        if True in list(map(lambda item: isinstance(item, NodeItem) and hasattr(item.node(), "console"), items)):
-            console_action = QtWidgets.QAction("Console", menu)
-            console_action.setIcon(QtGui.QIcon(':/icons/console.svg'))
-            console_action.triggered.connect(self.consoleActionSlot)
-            menu.addAction(console_action)
-
-        if True in list(map(lambda item: isinstance(item, NodeItem) and hasattr(item.node(), "console"), items)):
-            console_edit_action = QtWidgets.QAction("Custom console", menu)
-            console_edit_action.setIcon(QtGui.QIcon(':/icons/console_edit.svg'))
-            console_edit_action.triggered.connect(self.customConsoleActionSlot)
-            menu.addAction(console_edit_action)
-
-        if True in list(map(lambda item: isinstance(item, NodeItem) and hasattr(item.node(), "auxConsole"), items)):
-            aux_console_action = QtWidgets.QAction("Auxiliary console", menu)
-            aux_console_action.setIcon(QtGui.QIcon(':/icons/aux-console.svg'))
-            aux_console_action.triggered.connect(self.auxConsoleActionSlot)
-            menu.addAction(aux_console_action)
-
        if sys.platform.startswith("win") and True in list(map(lambda item: isinstance(item, NodeItem) and hasattr(item.node(), "bringToFront"), items)):
            # Action: bring console or window to front (Windows only)
            bring_to_front_action = QtWidgets.QAction("Bring to front", menu)
-            bring_to_front_action.setIcon(QtGui.QIcon(':/icons/front.svg'))
+            bring_to_front_action.setIcon(get_icon("front.svg"))
            bring_to_front_action.triggered.connect(self.bringToFrontSlot)
            menu.addAction(bring_to_front_action)

-        if True in list(map(lambda item: isinstance(item, NodeItem) and hasattr(item.node(), "configFiles"), items)):
+        if True in list(map(lambda item: isinstance(item, NodeItem) and bool(item.node().configFiles()), items)):
            import_config_action = QtWidgets.QAction("Import config", menu)
-            import_config_action.setIcon(QtGui.QIcon(':/icons/import_config.svg'))
+            import_config_action.setIcon(get_icon("import.svg"))
            import_config_action.triggered.connect(self.importConfigActionSlot)
            menu.addAction(import_config_action)

-        if True in list(map(lambda item: isinstance(item, NodeItem) and hasattr(item.node(), "configFiles"), items)):
+        if True in list(map(lambda item: isinstance(item, NodeItem) and bool(item.node().configFiles()), items)):
            export_config_action = QtWidgets.QAction("Export config", menu)
-            export_config_action.setIcon(QtGui.QIcon(':/icons/export_config.svg'))
+            export_config_action.setIcon(get_icon("export.svg"))
            export_config_action.triggered.connect(self.exportConfigActionSlot)
            menu.addAction(export_config_action)

-        if True in list(map(lambda item: isinstance(item, NodeItem) and hasattr(item.node(), "configFiles"), items)):
+        if True in list(map(lambda item: isinstance(item, NodeItem) and bool(item.node().configTextFiles()), items)):
            export_config_action = QtWidgets.QAction("Edit config", menu)
-            export_config_action.setIcon(QtGui.QIcon(':/icons/edit.svg'))
+            export_config_action.setIcon(get_icon("edit.svg"))
            export_config_action.triggered.connect(self.editConfigActionSlot)
            menu.addAction(export_config_action)

        if True in list(map(lambda item: isinstance(item, NodeItem) and hasattr(item.node(), "idlepc"), items)):
            idlepc_action = QtWidgets.QAction("Idle-PC", menu)
-            idlepc_action.setIcon(QtGui.QIcon(':/icons/calculate.svg'))
+            idlepc_action.setIcon(get_icon("calculate.svg"))
            idlepc_action.triggered.connect(self.idlepcActionSlot)
            menu.addAction(idlepc_action)

        if True in list(map(lambda item: isinstance(item, NodeItem) and hasattr(item.node(), "idlepc"), items)):
            auto_idlepc_action = QtWidgets.QAction("Auto Idle-PC", menu)
-            auto_idlepc_action.setIcon(QtGui.QIcon(':/icons/calculate.svg'))
+            auto_idlepc_action.setIcon(get_icon("calculate.svg"))
            auto_idlepc_action.triggered.connect(self.autoIdlepcActionSlot)
            menu.addAction(auto_idlepc_action)

-        if True in list(map(lambda item: isinstance(item, NodeItem) and not item.node().isAlwaysOn(), items)):
-            start_action = QtWidgets.QAction("Start", menu)
-            start_action.setIcon(QtGui.QIcon(':/icons/start.svg'))
-            start_action.triggered.connect(self.startActionSlot)
-            menu.addAction(start_action)
-
-        if True in list(map(lambda item: isinstance(item, NodeItem) and not item.node().isAlwaysOn(), items)):
-            suspend_action = QtWidgets.QAction("Suspend", menu)
-            suspend_action.setIcon(QtGui.QIcon(':/icons/pause.svg'))
-            suspend_action.triggered.connect(self.suspendActionSlot)
-            menu.addAction(suspend_action)
-
-        if True in list(map(lambda item: isinstance(item, NodeItem) and not item.node().isAlwaysOn(), items)):
-            stop_action = QtWidgets.QAction("Stop", menu)
-            stop_action.setIcon(QtGui.QIcon(':/icons/stop.svg'))
-            stop_action.triggered.connect(self.stopActionSlot)
-            menu.addAction(stop_action)
-
-        if True in list(map(lambda item: isinstance(item, NodeItem) and not item.node().isAlwaysOn(), items)):
-            reload_action = QtWidgets.QAction("Reload", menu)
-            reload_action.setIcon(QtGui.QIcon(':/icons/reload.svg'))
-            reload_action.triggered.connect(self.reloadActionSlot)
-            menu.addAction(reload_action)
-
-        if True in list(map(lambda item: isinstance(item, NoteItem), items)):
+        if True in list(map(lambda item: isinstance(item, LabelItem), items)):
            text_edit_action = QtWidgets.QAction("Text edit", menu)
-            text_edit_action.setIcon(QtGui.QIcon(':/icons/show-hostname.svg'))
+            text_edit_action.setIcon(get_icon("show-hostname.svg"))
            text_edit_action.triggered.connect(self.textEditActionSlot)
            menu.addAction(text_edit_action)

        if True in list(map(lambda item: isinstance(item, TextItem), items)):
            text_edit_action = QtWidgets.QAction("Text edit", menu)
-            text_edit_action.setIcon(QtGui.QIcon(':/icons/edit.svg'))
+            text_edit_action.setIcon(get_icon("edit.svg"))
            text_edit_action.triggered.connect(self.textEditActionSlot)
            menu.addAction(text_edit_action)

        if True in list(map(lambda item: isinstance(item, ShapeItem) or isinstance(item, LineItem), items)):
            style_action = QtWidgets.QAction("Style", menu)
-            style_action.setIcon(QtGui.QIcon(':/icons/drawing.svg'))
+            style_action.setIcon(get_icon("node_conception.svg"))
            style_action.triggered.connect(self.styleActionSlot)
            menu.addAction(style_action)

-        if True in list(map(lambda item: isinstance(item, NodeItem) and hasattr(item.node(), "commandLine"), items)):
-            # Action: Get command line
-            show_in_file_manager_action = QtWidgets.QAction("Command line", menu)
-            show_in_file_manager_action.setIcon(QtGui.QIcon(':/icons/console.svg'))
-            show_in_file_manager_action.triggered.connect(self.getCommandLineSlot)
-            menu.addAction(show_in_file_manager_action)
-
-        if True in list(map(lambda item: isinstance(item, NoteItem), items)) and False in list(map(lambda item: item.parentItem() is None, items)):
+        if True in list(map(lambda item: isinstance(item, LabelItem), items)) and False in list(map(lambda item: item.parentItem() is None, items)):
            # action only for port labels
            reset_label_position_action = QtWidgets.QAction("Reset position", menu)
-            reset_label_position_action.setIcon(QtGui.QIcon(':/icons/reset.svg'))
+            reset_label_position_action.setIcon(get_icon("reset.svg"))
            reset_label_position_action.triggered.connect(self.resetLabelPositionActionSlot)
            menu.addAction(reset_label_position_action)

@@ -851,27 +921,41 @@ class GraphicsView(QtWidgets.QGraphicsView):

            if len(items) > 1:
                horizontal_align_action = QtWidgets.QAction("Align horizontally", menu)
-                horizontal_align_action.setIcon(QtGui.QIcon(':/icons/horizontally.svg'))
+                horizontal_align_action.setIcon(get_icon("horizontally.svg"))
                horizontal_align_action.triggered.connect(self.horizontalAlignmentSlot)
                menu.addAction(horizontal_align_action)

                vertical_align_action = QtWidgets.QAction("Align vertically", menu)
-                vertical_align_action.setIcon(QtGui.QIcon(':/icons/vertically.svg'))
+                vertical_align_action.setIcon(get_icon("vertically.svg"))
                vertical_align_action.triggered.connect(self.verticalAlignmentSlot)
                menu.addAction(vertical_align_action)

            raise_layer_action = QtWidgets.QAction("Raise one layer", menu)
-            raise_layer_action.setIcon(QtGui.QIcon(':/icons/raise_z_value.svg'))
+            raise_layer_action.setIcon(get_icon("raise_z_value.svg"))
            raise_layer_action.triggered.connect(self.raiseLayerActionSlot)
            menu.addAction(raise_layer_action)

            lower_layer_action = QtWidgets.QAction("Lower one layer", menu)
-            lower_layer_action.setIcon(QtGui.QIcon(':/icons/lower_z_value.svg'))
+            lower_layer_action.setIcon(get_icon("lower_z_value.svg"))
            lower_layer_action.triggered.connect(self.lowerLayerActionSlot)
            menu.addAction(lower_layer_action)

+            if len(items) > 1:
+                lock_action = QtWidgets.QAction("Lock or unlock items", menu)
+                lock_action.setIcon(get_icon("lock.svg"))
+            else:
+                item = items[0]
+                if item.flags() & QtWidgets.QGraphicsItem.ItemIsMovable:
+                    lock_action = QtWidgets.QAction("Lock item", menu)
+                    lock_action.setIcon(get_icon("lock.svg"))
+                else:
+                    lock_action = QtWidgets.QAction("Unlock item", menu)
+                    lock_action.setIcon(get_icon("unlock.svg"))
+            lock_action.triggered.connect(self.lockActionSlot)
+            menu.addAction(lock_action)
+
            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)

@@ -939,6 +1023,9 @@ class GraphicsView(QtWidgets.QGraphicsView):
            if isinstance(item, NodeItem) and item.node().initialized():
                new_hostname, ok = QtWidgets.QInputDialog.getText(self, "Change hostname", "Hostname:", QtWidgets.QLineEdit.Normal, item.node().name())
                if ok:
+                    if not new_hostname.strip():
+                        QtWidgets.QMessageBox.critical(self, "Change hostname", "Hostname cannot be blank")
+                        continue
                    if hasattr(item.node(), "validateHostname"):
                        if not item.node().validateHostname(new_hostname):
                            QtWidgets.QMessageBox.critical(self, "Change hostname", "Invalid name detected for this node: {}".format(new_hostname))
@@ -1005,8 +1092,7 @@ class GraphicsView(QtWidgets.QGraphicsView):

        # TightVNC has lack support of IPv6 host at this moment
        if "vncviewer" in node.consoleCommand() and ":" in node.consoleHost():
-            QtWidgets.QMessageBox.warning(
-                self, "TightVNC", "TightVNC (vncviewer) may not start because of lack of IPv6 support.")
+            QtWidgets.QMessageBox.warning(self, "TightVNC", "TightVNC (vncviewer) may not start because of lack of IPv6 support.")

        try:
            node.openConsole(aux=aux)
@@ -1025,7 +1111,7 @@ class GraphicsView(QtWidgets.QGraphicsView):
        nodes = {}
        node_initialized = False
        for item in items:
-            if isinstance(item, NodeItem) and hasattr(item.node(), "console") and item.node().initialized():
+            if isinstance(item, NodeItem) and item.node().console() is not None and item.node().initialized():
                node_initialized = True
                if item.node().status() == Node.started:
                    node = item.node()
@@ -1047,11 +1133,21 @@ class GraphicsView(QtWidgets.QGraphicsView):

    def consoleFromAllItems(self):
        """
-        Console from all scene items, except builtin devices.
+        Console from all scene items with console type different than "none"
        """

        items = [item for item in self.scene().items()
-                 if not (isinstance(item, NodeItem) and isinstance(item.node().module(), Builtin))]
+                 if isinstance(item, NodeItem) and item.node().consoleType() != "none"]
+        nb_items = len(items)
+        if nb_items > 10:
+            proceed = QtWidgets.QMessageBox.question(self,
+                                                     "Console to all nodes",
+                                                     "You are about to open console windows to {} nodes. Are you sure?".format(nb_items),
+                                                     QtWidgets.QMessageBox.Yes,
+                                                     QtWidgets.QMessageBox.No)
+
+            if proceed == QtWidgets.QMessageBox.No:
+                return
        self.consoleFromItems(items)

    def consoleActionSlot(self):
@@ -1067,24 +1163,20 @@ class GraphicsView(QtWidgets.QGraphicsView):
        Allow user to use a custom console for this VM
        """

-        current_cmd = None
-        console_type = "telnet"
        for item in self.scene().selectedItems():
-            if isinstance(item, NodeItem) and hasattr(item.node(), "console") and item.node().initialized() and item.node().status() == Node.started:
-                if item.node().consoleType() not in ("telnet", "serial", "vnc", "spice"):
+            if isinstance(item, NodeItem) and item.node().console() is not None and item.node().initialized():
+                if item.node().consoleType() not in ("telnet", "serial", "vnc", "spice", "spice+agent"):
                    continue
                current_cmd = item.node().consoleCommand()
                console_type = item.node().consoleType()

-        (ok, cmd) = ConsoleCommandDialog.getCommand(self, console_type=console_type, current=current_cmd)
-        if ok:
-            for item in self.scene().selectedItems():
-                if isinstance(item, NodeItem) and hasattr(item.node(), "console") and item.node().initialized() and item.node().status() == Node.started:
-                    node = item.node()
-                    if node.consoleType() not in ("telnet", "serial", "vnc", "spice"):
-                        continue
+                (ok, cmd) = ConsoleCommandDialog.getCommand(self, console_type=console_type, current=current_cmd)
+                if ok:
                    try:
-                        node.openConsole(command=cmd)
+                        if item.node().status() != Node.started:
+                            QtWidgets.QMessageBox.warning(self, "Console", "This node must be started before a console can be opened")
+                            continue
+                        item.node().openConsole(command=cmd)
                    except (OSError, ValueError) as e:
                        QtWidgets.QMessageBox.critical(self, "Console", "Cannot start console application: {}".format(e))

@@ -1134,7 +1226,7 @@ class GraphicsView(QtWidgets.QGraphicsView):

        items = []
        for item in self.scene().selectedItems():
-            if isinstance(item, NodeItem) and hasattr(item.node(), "configFiles") and item.node().initialized():
+            if isinstance(item, NodeItem) and item.node().configFiles() and item.node().initialized():
                items.append(item)

        if not items:
@@ -1148,17 +1240,14 @@ class GraphicsView(QtWidgets.QGraphicsView):
                if not ok:
                    continue

-            if not self._import_config_dir:
-                self._import_config_dir = QtCore.QStandardPaths.writableLocation(QtCore.QStandardPaths.DownloadLocation)
-
            path, _ = QtWidgets.QFileDialog.getOpenFileName(self,
                                                            "Import {}".format(os.path.basename(config_file)),
-                                                            self._import_config_dir,
+                                                            self._import_config_directory,
                                                            "All files (*.*);;Config files (*.cfg)",
                                                            "Config files (*.cfg)")
            if not path:
                continue
-            self._import_config_dir = os.path.dirname(path)
+            self._import_config_directory = os.path.dirname(path)
            item.node().importFile(config_file, path)

    def editConfigActionSlot(self):
@@ -1168,17 +1257,17 @@ class GraphicsView(QtWidgets.QGraphicsView):

        items = []
        for item in self.scene().selectedItems():
-            if isinstance(item, NodeItem) and hasattr(item.node(), "configFiles") and item.node().initialized():
+            if isinstance(item, NodeItem) and item.node().configTextFiles() and item.node().initialized():
                items.append(item)

        if not items:
            return

        for item in items:
-            if len(item.node().configFiles()) == 1:
-                config_file = item.node().configFiles()[0]
+            if len(item.node().configTextFiles()) == 1:
+                config_file = item.node().configTextFiles()[0]
            else:
-                config_file, ok = QtWidgets.QInputDialog.getItem(self, "Edit file", "File to edit?", item.node().configFiles(), 0, False)
+                config_file, ok = QtWidgets.QInputDialog.getItem(self, "Edit file", "File to edit?", item.node().configTextFiles(), 0, False)
                if not ok:
                    continue
            dialog = FileEditorDialog(item.node(), config_file, parent=self)
@@ -1193,47 +1282,35 @@ class GraphicsView(QtWidgets.QGraphicsView):

        items = []
        for item in self.scene().selectedItems():
-            if isinstance(item, NodeItem) and hasattr(item.node(), "configFiles") and item.node().initialized():
+            if isinstance(item, NodeItem) and item.node().configFiles() and item.node().initialized():
                items.append(item)

        if not items:
            return

-        if not self._export_configs_to_dir:
-            self._export_configs_to_dir = QtCore.QStandardPaths.writableLocation(QtCore.QStandardPaths.DownloadLocation)
-
        for item in items:
            for config_file in item.node().configFiles():
-                path, ok = QtWidgets.QFileDialog.getSaveFileName(self, "Export file", os.path.join(self._export_configs_to_dir, item.node().name() + "_" + os.path.basename(config_file)), "All files (*.*);;Config files (*.cfg)")
+                path, ok = QtWidgets.QFileDialog.getSaveFileName(self, "Export file", os.path.join(self._export_config_directory, item.node().name() + "_" + os.path.basename(config_file)), "All files (*.*);;Config files (*.cfg)")
                if not path:
                    continue
-                self._export_configs_to_dir = os.path.dirname(path)
+                self._export_config_directory = os.path.dirname(path)
                item.node().exportFile(config_file, path)

-    def getCommandLineSlot(self):
+    def showNodeInfoSlot(self):
        """
-        Slot to receive events from the get command line action in the
+        Slot to receive events from the show node info action in the
        contextual menu.
        """

        items = self.scene().selectedItems()
        if len(items) != 1:
-            QtWidgets.QMessageBox.critical(self, "Command line", "Please select only one router")
+            QtWidgets.QMessageBox.critical(self, "Show node information", "Please select only one node")
            return
        item = items[0]
-        if isinstance(item, NodeItem) and hasattr(item.node(), "commandLine"):
-            router = item.node()
-            if router.commandLine() is None:
-                QtWidgets.QMessageBox.warning(self, "Command line", "Get command line is not supported for this type of node.")
-            elif router.commandLine() == '':
-                QtWidgets.QMessageBox.warning(self, "Command line", "Please start the node in order to get the command line.")
-            else:
-                dialog = QtWidgets.QInputDialog(self)
-                dialog.setOptions(QtWidgets.QInputDialog.NoButtons)
-                dialog.setLabelText("Command used to start the VM:")
-                dialog.setTextValue(router.commandLine())
-                dialog.show()
-                dialog.exec_()
+        if isinstance(item, NodeItem):
+            dialog = NodeInfoDialog(item.node(), parent=self)
+            dialog.show()
+            dialog.exec_()

    def bringToFrontSlot(self):
        """
@@ -1312,9 +1389,9 @@ class GraphicsView(QtWidgets.QGraphicsView):
                    node.setIdlepc(idlepc)
            # apply the idle-pc to templates with the same IOS image
            router.module().updateImageIdlepc(ios_image, idlepc)
-            QtWidgets.QMessageBox.information(self, "Auto Idle-PC", "Idle-PC value {} has been applied on {} and all routers with IOS image {}".format(idlepc,
-                                                                                                                                                       router.name(),
-                                                                                                                                                       ios_image))
+            QtWidgets.QMessageBox.information(self, "Auto Idle-PC", "Idle-PC value {} has been applied on {} and all templates with IOS image {}".format(idlepc,
+                                                                                                                                                         router.name(),
+                                                                                                                                                         ios_image))

    def duplicateActionSlot(self):
        """
@@ -1359,7 +1436,7 @@ class GraphicsView(QtWidgets.QGraphicsView):

        items = []
        for item in self.scene().selectedItems():
-            if isinstance(item, NoteItem) or isinstance(item, TextItem):
+            if isinstance(item, LabelItem) or isinstance(item, TextItem):
                items.append(item)
        if items:
            text_edit_dialog = TextEditorDialog(self._main_window, items)
@@ -1373,7 +1450,7 @@ class GraphicsView(QtWidgets.QGraphicsView):
        """

        for item in self.scene().selectedItems():
-            if isinstance(item, NoteItem) and item.parentItem():
+            if isinstance(item, LabelItem) and item.parentItem():
                links = item.parentItem().links()
                for port in item.parentItem().node().ports():
                    # find the correct port associated with the label
@@ -1422,8 +1499,10 @@ class GraphicsView(QtWidgets.QGraphicsView):

        for item in self.scene().selectedItems():
            if item.parentItem() is None:
-                current_zvalue = item.zValue()
-                item.setZValue(current_zvalue + 1)
+                if not (item.flags() & QtWidgets.QGraphicsItem.ItemIsMovable):
+                    log.error("Cannot move object to a upper layer because it is locked")
+                    continue
+                item.setZValue(item.zValue() + 1)
                item.updateNode()
                item.update()

@@ -1435,13 +1514,28 @@ class GraphicsView(QtWidgets.QGraphicsView):

        for item in self.scene().selectedItems():
            if item.parentItem() is None:
-                current_zvalue = item.zValue()
-                item.setZValue(current_zvalue - 1)
+                if not (item.flags() & QtWidgets.QGraphicsItem.ItemIsMovable):
+                    log.error("Cannot move object to a lower layer because it is locked")
+                    continue
+                item.setZValue(item.zValue() - 1)
                item.updateNode()
                item.update()

-                if item.zValue() == -1:
-                    self._background_warning_msgbox.showMessage("Object moved to a background layer. You will now have to use the right-click action to select this object in the future and raise it to layer 0 to be able to move it")
+    def lockActionSlot(self):
+        """
+        Slot to receive events from the lock action in the
+        contextual menu.
+        """
+
+        for item in self.scene().selectedItems():
+            if not isinstance(item, LinkItem) and not isinstance(item, LabelItem) and not isinstance(item, SvgIconItem):
+                if item.locked() is True:
+                    item.setLocked(False)
+                else:
+                    item.setLocked(True)
+                if item.parentItem() is None:
+                    item.updateNode()
+                item.update()

    def deleteActionSlot(self):
        """
@@ -1452,7 +1546,14 @@ class GraphicsView(QtWidgets.QGraphicsView):
        selected_nodes = []
        for item in self.scene().selectedItems():
            if isinstance(item, NodeItem):
-                selected_nodes.append(item.node())
+                node = item.node()
+                if node.locked():
+                    QtWidgets.QMessageBox.critical(self, "Delete", "Cannot delete node '{}' because it is locked".format(node.name()))
+                    return
+                selected_nodes.append(node)
+            if isinstance(item, DrawingItem) and item.locked():
+                QtWidgets.QMessageBox.critical(self, "Delete", "Cannot delete drawing because it is locked")
+                return
        if selected_nodes:
            if len(selected_nodes) > 1:
                question = "Do you want to permanently delete these {} nodes?".format(len(selected_nodes))
@@ -1481,23 +1582,23 @@ class GraphicsView(QtWidgets.QGraphicsView):
        from .main_window import MainWindow
        mainwindow = MainWindow.instance()

-        if "server" in node_data:
+        if "compute_id" in node_data:
            try:
-                return ComputeManager.instance().getCompute(node_data["server"])
+                return ComputeManager.instance().getCompute(node_data["compute_id"])
            except KeyError:
-                raise ModuleError("Compute {} doesn't exists".format(node_data["server"]))
+                raise ModuleError("Compute {} doesn't exists".format(node_data["compute_id"]))

        server = server_select(mainwindow, node_data.get("node_type"))
        if server is None:
            raise ModuleError("Please select a server")
        return server

-    def createNodeFromApplianceId(self, appliance_id, pos):
+    def createNodeFromTemplateId(self, template_id, pos):
        """
-        Ask the server to create a node using this appliance
+        Ask the server to create a node using this template
        """
        pos = self.mapToScene(pos)
-        return ApplianceManager().instance().createNodeFromApplianceId(self._topology.project(), appliance_id, pos.x(), pos.y())
+        return TemplateManager().instance().createNodeFromTemplateId(self._topology.project(), template_id, pos.x(), pos.y())

    def createNodeItem(self, node, symbol, x, y):
        node.setSymbol(symbol)
@@ -1524,18 +1625,18 @@ class GraphicsView(QtWidgets.QGraphicsView):
        if self._main_window and not sip.isdeleted(self._main_window):
            QtWidgets.QMessageBox.critical(self._main_window, name, message.strip())

-    def createDrawingItem(self, type, x, y, z, rotation=0, svg=None, drawing_id=None):
+    def createDrawingItem(self, type, x, y, z, locked=False, rotation=0, svg=None, drawing_id=None):

        if type == "ellipse":
-            item = EllipseItem(pos=QtCore.QPoint(x, y), z=z, rotation=rotation, project=self._topology.project(), drawing_id=drawing_id, svg=svg)
+            item = EllipseItem(pos=QtCore.QPoint(x, y), z=z, locked=locked, rotation=rotation, project=self._topology.project(), drawing_id=drawing_id, svg=svg)
        elif type == "rect":
-            item = RectangleItem(pos=QtCore.QPoint(x, y), z=z, rotation=rotation, project=self._topology.project(), drawing_id=drawing_id, svg=svg)
+            item = RectangleItem(pos=QtCore.QPoint(x, y), z=z, locked=locked, rotation=rotation, project=self._topology.project(), drawing_id=drawing_id, svg=svg)
        elif type == "line":
-            item = LineItem(pos=QtCore.QPoint(x, y), dst=QtCore.QPoint(200, 0), z=z, rotation=rotation, project=self._topology.project(), drawing_id=drawing_id, svg=svg)
+            item = LineItem(pos=QtCore.QPoint(x, y), dst=QtCore.QPoint(200, 0), z=z, locked=locked, rotation=rotation, project=self._topology.project(), drawing_id=drawing_id, svg=svg)
        elif type == "image":
-            item = ImageItem(pos=QtCore.QPoint(x, y), z=z, rotation=rotation, project=self._topology.project(), drawing_id=drawing_id, svg=svg)
+            item = ImageItem(pos=QtCore.QPoint(x, y), z=z, rotation=rotation, locked=locked, project=self._topology.project(), drawing_id=drawing_id, svg=svg)
        elif type == "text":
-            item = TextItem(pos=QtCore.QPoint(x, y), z=z, rotation=rotation, project=self._topology.project(), drawing_id=drawing_id, svg=svg)
+            item = TextItem(pos=QtCore.QPoint(x, y), z=z, rotation=rotation, locked=locked, project=self._topology.project(), drawing_id=drawing_id, svg=svg)

        if drawing_id is None:
            item.create()
@@ -1547,21 +1648,25 @@ class GraphicsView(QtWidgets.QGraphicsView):
    def drawBackground(self, painter, rect):
        super().drawBackground(painter, rect)
        if self._main_window.uiShowGridAction.isChecked():
-            gridSize = 75
+            grids = [(self.drawingGridSize(), QtGui.QColor(208, 208, 208)),
+                     (self.nodeGridSize(), QtGui.QColor(190, 190, 190))]
            painter.save()
-            painter.setPen(QtGui.QPen(QtGui.QColor(190, 190, 190)))
+            for (grid, colour) in grids:
+                if not grid:
+                    continue
+                painter.setPen(QtGui.QPen(colour))

-            left = int(rect.left()) - (int(rect.left()) % gridSize)
-            top = int(rect.top()) - (int(rect.top()) % gridSize)
+                left = int(rect.left()) - (int(rect.left()) % grid)
+                top = int(rect.top()) - (int(rect.top()) % grid)

-            x = left
-            while x < rect.right():
-                painter.drawLine(x, rect.top(), x, rect.bottom())
-                x += gridSize
-            y = top
-            while y < rect.bottom():
-                painter.drawLine(rect.left(), y, rect.right(), y)
-                y += gridSize
+                x = left
+                while x < rect.right():
+                    painter.drawLine(x, rect.top(), x, rect.bottom())
+                    x += grid
+                y = top
+                while y < rect.bottom():
+                    painter.drawLine(rect.left(), y, rect.right(), y)
+                    y += grid
            painter.restore()

    def toggleUiDeviceMenu(self):
--- a/gns3/http_client.py
+++ b/gns3/http_client.py
@@ -15,21 +15,18 @@
 # 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 sip
+from .qt import sip
 import json
 import copy
-import http
 import uuid
 import pathlib
 import base64
-import datetime
 import ipaddress
 import urllib.request
 import urllib.parse

-
 from .version import __version__, __version_info__
-from .qt import QtCore, QtNetwork, qpartial, sip_is_deleted, QtWebSockets
+from .qt import QtCore, QtNetwork, QtWidgets, qpartial, sip_is_deleted
 from .utils import parse_version

 import logging
@@ -47,7 +44,7 @@ class HTTPClient(QtCore.QObject):
    """
    HTTP client.

-    :param settings: Dictionnary with connection information to the server
+    :param settings: Dictionary with connection information to the server
    :param network_manager: A QT network manager
    """

@@ -79,6 +76,18 @@ class HTTPClient(QtCore.QObject):
        self._shutdown = False  # Shutdown in progress
        self._accept_insecure_certificate = settings.get("accept_insecure_certificate", None)

+        # Add custom CA
+        # ssl_config = QtNetwork.QSslConfiguration.defaultConfiguration()
+        # if ssl_config.addCaCertificates("/path/to/rootCA.crt"):
+        #     log.debug("CA certificate added")
+        # QtNetwork.QSslConfiguration.setDefaultConfiguration(ssl_config)
+
+        if self._protocol == "https":
+            if not QtNetwork.QSslSocket.supportsSsl():
+                log.error("SSL is not supported")
+            else:
+                log.debug(f"SSL is supported, version: {QtNetwork.QSslSocket().sslLibraryBuildVersionString()}")
+
        # In order to detect computer hibernation we detect the date of the last
        # query and disconnect if time is too long between two query
        self._last_query_timestamp = None
@@ -93,7 +102,11 @@ class HTTPClient(QtCore.QObject):
        # List of query waiting for the connection
        self._query_waiting_connections = []

-        self._websocket = QtWebSockets.QWebSocket()
+        # To catch SSL errors
+        self._network_manager.sslErrors.connect(self._sslErrorsSlot)
+
+        # Store SSL error exceptions
+        self._ssl_exceptions = {}

    def setMaxTimeDifferenceBetweenQueries(self, value):
        self._max_time_difference_between_queries = value
@@ -209,16 +222,16 @@ class HTTPClient(QtCore.QObject):
        Called when a query upload progress
        """
        if not sip_is_deleted(HTTPClient._progress_callback):
-            HTTPClient._progress_callback.progress_signal.emit(query_id, str(sent), str(total))
+            HTTPClient._progress_callback.progress_signal.emit(query_id, str(abs(sent)), str(abs(total)))

    def _notify_progress_download(self, query_id, sent, total):
        """
        Called when a query download progress
        """
        if not sip_is_deleted(HTTPClient._progress_callback):
-            # abs() for maxium because sometimes the system send negative
+            # abs() for maximum because sometimes the system send negative
            # values
-            HTTPClient._progress_callback.progress_signal.emit(query_id, str(sent), str(abs(total)))
+            HTTPClient._progress_callback.progress_signal.emit(query_id, str(abs(sent)), str(abs(total)))

    @classmethod
    def setProgressCallback(cls, progress_callback):
@@ -303,16 +316,17 @@ class HTTPClient(QtCore.QObject):
        if self._shutdown:
            return

+        # TODO: clean this
        # We try to detect computer hibernation
        # if time between two query is too long we trigger a disconnect
-        if self._max_time_difference_between_queries:
-            now = datetime.datetime.now().timestamp()
-            if self._last_query_timestamp is not None and now > self._last_query_timestamp + self._max_time_difference_between_queries:
-                log.warning("Synchronisation lost with the server.")
-                self.disconnect()
-                self._last_query_timestamp = None
-                return
-            self._last_query_timestamp = now
+        # if self._max_time_difference_between_queries:
+        #     now = datetime.datetime.now().timestamp()
+        #     if self._last_query_timestamp is not None and now > self._last_query_timestamp + self._max_time_difference_between_queries:
+        #         log.warning("Synchronisation lost with the server.")
+        #         self.disconnect()
+        #         self._last_query_timestamp = None
+        #         return
+        #     self._last_query_timestamp = now

        request = qpartial(self._executeHTTPQuery, method, path, qpartial(callback), body, context,
                           downloadProgressCallback=downloadProgressCallback,
@@ -391,7 +405,7 @@ class HTTPClient(QtCore.QObject):
            return

        if params["version"].split("-")[0] != __version__.split("-")[0]:
-            msg = "Client version {} is not the same as server version {}".format(__version__, params["version"])
+            msg = "Client version {} is not the same as server (controller) version {}".format(__version__, params["version"])
            # Stable release
            if __version_info__[3] == 0:
                log.error(msg)
@@ -406,7 +420,7 @@ class HTTPClient(QtCore.QObject):
                    if callback is not None:
                        callback({"message": msg}, error=True, server=server)
                return
-            log.warning("{}\nUsing different versions may result in unexpected problems. Please use at your own risk.".format(msg))
+            log.warning("{}\nUsing different versions may result in unexpected problems. Please upgrade or use at your own risk.".format(msg))

        self._connected = True
        self._retry = 0
@@ -465,16 +479,25 @@ class HTTPClient(QtCore.QObject):
            request.setRawHeader(b"Authorization", auth_string.encode())
        return request

-    def connectWebSocket(self, path, prefix="/v2"):
+    def connectWebSocket(self, websocket, path, prefix="/v2"):
        """
        Path of the websocket endpoint
        """
        host = self._getHostForQuery()
-        request = self._websocket.request()
-        request.setUrl(QtCore.QUrl("ws://{host}:{port}{prefix}{path}".format(host=host, port=self._port, path=path, prefix=prefix)))
+        request = websocket.request()
+        ws_protocol = "ws"
+        if self._protocol == "https":
+            ws_protocol = "wss"
+        ws_url = "{protocol}://{host}:{port}{prefix}{path}".format(protocol=ws_protocol,
+                                                                   host=host,
+                                                                   port=self._port,
+                                                                   path=path,
+                                                                   prefix=prefix)
+        log.debug("Connecting to WebSocket endpoint: {}".format(ws_url))
+        request.setUrl(QtCore.QUrl(ws_url))
        self._addAuth(request)
-        self._websocket.open(request)
-        return self._websocket
+        websocket.open(request)
+        return websocket

    def _getHostForQuery(self):
        """
@@ -491,7 +514,7 @@ class HTTPClient(QtCore.QObject):

    def _paramsToQueryString(self, params):
        """
-        :param params: Dictionnary of query string parameters
+        :param params: Dictionary of query string parameters
        :returns: String of the query string
        """
        if params == {}:
@@ -619,7 +642,7 @@ class HTTPClient(QtCore.QObject):
        # We check if we received HTTP headers
        if not sip.isdeleted(response) and response.isRunning() and not len(response.rawHeaderList()) > 0:
            if not response.error() != QtNetwork.QNetworkReply.NoError:
-                log.warning("Timeout after {} seconds for request {}".format(timeout, response.url().toString()))
+                log.warning("Timeout after {} seconds for request {}. Please check the connection is not blocked by a firewall or an anti-virus.".format(timeout, response.url().toString()))
                response.abort()

    def disconnect(self):
@@ -632,14 +655,14 @@ class HTTPClient(QtCore.QObject):
    def _requestCanceled(self, response, context):

        if response.isRunning() and not response.error() != QtNetwork.QNetworkReply.NoError:
-            log.warn("Aborting request for {}".format(response.url().toString()))
+            log.warning("Aborting request for {}".format(response.url().toString()))
            response.abort()
        if "query_id" in context:
            self._notify_progress_end_query(context["query_id"])

    def _processError(self, response, server, callback, context, request_body, ignore_errors, error_code):
        if error_code != QtNetwork.QNetworkReply.NoError:
-            error_message = response.errorString()
+            error_message = "{} ({}:{})".format(response.errorString(), self._host, self._port)

            if not ignore_errors:
                log.debug("Response error: %s for %s (error: %d)", error_message, response.url().toString(), error_code)
@@ -649,7 +672,10 @@ class HTTPClient(QtCore.QObject):

            if error_code < 200 or error_code == 403:
                if error_code == QtNetwork.QNetworkReply.OperationCanceledError:  # It's legit to cancel do not disconnect
-                    error_message = "Operation timeout"  # It's more clear than cancel, because cancel is trigger by us when we timeout
+                    error_message = "Operation timeout"  # It's clearer than cancel because cancel is triggered by us when we timeout
+                elif error_code == QtNetwork.QNetworkReply.NetworkSessionFailedError:
+                    # ignore the network session failed error to let the network manager recover from it
+                    return
                elif not ignore_errors:
                    self.disconnect()
                if callback is not None:
@@ -723,47 +749,103 @@ class HTTPClient(QtCore.QObject):
                    e = HttpBadRequest(body)
                raise e

-    def getSynchronous(self, endpoint, timeout=2):
+    def getSynchronous(self, method, endpoint, prefix="/v2", timeout=5):
        """
        Synchronous check if a server is running

-        :returns: Tuple (Status code, json of anwser). Status 0 is a non HTTP error
+        :returns: Tuple (Status code, json of answer). Status 0 is a non HTTP error
        """
-        try:
-            url = "{protocol}://{host}:{port}/v2/{endpoint}".format(protocol=self._protocol, host=self._host, port=self._port, endpoint=endpoint)

-            if self._user is not None and len(self._user) > 0:
-                log.debug("Synchronous get {} with user '{}'".format(url, self._user))
-                auth_handler = urllib.request.HTTPBasicAuthHandler()
-                auth_handler.add_password(realm="GNS3 server",
-                                          uri=url,
-                                          user=self._user,
-                                          passwd=self._password)
-                opener = urllib.request.build_opener(auth_handler)
-                urllib.request.install_opener(opener)
-            else:
-                log.debug("Synchronous get {} (no authentication)".format(url))
-            response = urllib.request.urlopen(url, timeout=timeout)
-            content_type = response.getheader("CONTENT-TYPE")
-            if response.status == 200:
-                if content_type == "application/json":
-                    content = response.read()
+        host = self._getHostForQuery()
+
+        log.debug("{method} {protocol}://{host}:{port}{prefix}{endpoint}".format(method=method, protocol=self._protocol, host=host, port=self._port, prefix=prefix, endpoint=endpoint))
+        if self._user:
+            url = QtCore.QUrl("{protocol}://{user}@{host}:{port}{prefix}{endpoint}".format(protocol=self._protocol, user=self._user, host=host, port=self._port, prefix=prefix, endpoint=endpoint))
+        else:
+            url = QtCore.QUrl("{protocol}://{host}:{port}{prefix}{endpoint}".format(protocol=self._protocol, host=host, port=self._port, prefix=prefix, endpoint=endpoint))
+
+        request = self._request(url)
+        request = self._addAuth(request)
+        request.setRawHeader(b"User-Agent", "GNS3 QT Client v{version}".format(version=__version__).encode())
+
+        try:
+            response = self._network_manager.sendCustomRequest(request, method.encode())
+        except SystemError as e:
+            log.error("Can't send query: {}".format(str(e)))
+            return
+
+        loop = QtCore.QEventLoop()
+        response.finished.connect(loop.quit)
+
+        if timeout is not None:
+            QtCore.QTimer.singleShot(timeout * 1000, qpartial(self._timeoutSlot, response, timeout))
+
+        if not loop.isRunning():
+            loop.exec_()
+
+        status = response.attribute(QtNetwork.QNetworkRequest.HttpStatusCodeAttribute)
+        if response.error() != QtNetwork.QNetworkReply.NoError:
+            log.debug("Error while connecting to local server {}".format(response.errorString()))
+        else:
+            content_type = response.header(QtNetwork.QNetworkRequest.ContentTypeHeader)
+            if status == 200 and content_type == "application/json":
+                content = bytes(response.readAll())
+                try:
                    json_data = json.loads(content.decode("utf-8"))
-                    return response.status, json_data
-            else:
-                return response.status, None
-        except http.client.InvalidURL as e:
-            log.warn("Invalid local server url: {}".format(e))
-            return 0, None
-        except urllib.error.URLError:
-            # Connection refused. It's a normal behavior if server is not started
-            return 0, None
-        except urllib.error.HTTPError as e:
-            log.debug("Error during get on {}:{}: {}".format(self.host(), self.port(), e))
-            return e.code, None
-        except (OSError, http.client.BadStatusLine, ValueError) as e:
-            log.debug("Error during get on {}:{}: {}".format(self.host(), self.port(), e))
-        return 0, None
+                except (UnicodeEncodeError, ValueError) as e:
+                    log.warning("Could not read JSON data returned from {}: {}".format(url, e))
+                else:
+                    return status, json_data
+        return status, None
+
+    def _sslErrorsSlot(self, response, ssl_errors):
+
+        self.handleSslError(response, ssl_errors)
+
+    def handleSslError(self, response, ssl_errors):
+
+        if self._accept_insecure_certificate:
+            response.ignoreSslErrors()
+            return
+
+        url = response.request().url()
+        host_port_key = f"{url.host()}:{url.port()}"
+
+        # get the certificate digest
+        ssl_config = response.sslConfiguration()
+        peer_cert = ssl_config.peerCertificate()
+        digest = peer_cert.digest()
+
+        if host_port_key in self._ssl_exceptions:
+
+            if self._ssl_exceptions[host_port_key] == digest:
+                response.ignoreSslErrors()
+                return
+
+        from gns3.main_window import MainWindow
+        main_window = MainWindow.instance()
+
+        msgbox = QtWidgets.QMessageBox(main_window)
+        msgbox.setWindowTitle("SSL error detected")
+        msgbox.setText(f"This server could not prove that it is {url.host()}:{url.port()}. Please carefully examine the certificate to make sure the server can be trusted.")
+        msgbox.setInformativeText(f"{ssl_errors[0].errorString()}")
+        msgbox.setDetailedText(peer_cert.toText())
+        msgbox.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding)
+        connect_button = QtWidgets.QPushButton(f"&Connect to {url.host()}:{url.port()}", msgbox)
+        msgbox.addButton(connect_button, QtWidgets.QMessageBox.YesRole)
+        abort_button = QtWidgets.QPushButton("&Abort", msgbox)
+        msgbox.addButton(abort_button, QtWidgets.QMessageBox.RejectRole)
+        msgbox.setDefaultButton(abort_button)
+        msgbox.setIcon(QtWidgets.QMessageBox.Critical)
+        msgbox.exec_()
+
+        if msgbox.clickedButton() == connect_button:
+            self._ssl_exceptions[host_port_key] = digest
+            response.ignoreSslErrors()
+        else:
+            for error in ssl_errors:
+                log.error(f"SSL error detected: {error.errorString()}")
+            main_window.close()

    @classmethod
    def fromUrl(cls, url, network_manager=None, base_settings=None):
--- a/gns3/image_manager.py
+++ b/gns3/image_manager.py
@@ -176,7 +176,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():
--- a/gns3/image_upload_manager.py
+++ b/gns3/image_upload_manager.py
@@ -15,6 +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/>.

+import os
 import pathlib
 import urllib.parse

@@ -37,16 +38,17 @@ class ImageUploadManager(object):
        self._controller = controller

    def upload(self):
+        if not os.path.exists(self._image.path):
+            log.error("Image '{}' could not be found".format(self._image.path))
+            return
        if self._directFileUpload:
            # first obtain endpoint and know when target request
-            self._controller.getEndpoint(
-                self._getComputePath(), self._compute_id, self._onLoadEndpointCallback, showProgress=False)
+            self._controller.getEndpoint(self._getComputePath(), self._compute_id, self._onLoadEndpointCallback, showProgress=False)
        else:
            self._fileUploadToController()

    def _getComputePath(self):
-        return '/{emulator}/images/{filename}'.format(
-            emulator=self._image.emulator, filename=self._image.filename)
+        return '/{emulator}/images/{filename}'.format(emulator=self._image.emulator, filename=self._image.filename)

    def _onLoadEndpointCallback(self, result, error=False, **kwargs):
        if error:
@@ -73,19 +75,16 @@ class ImageUploadManager(object):
        self._callback(result, error, **kwargs)

    def _fileUploadToCompute(self, endpoint):
-        log.info("Uploading file to compute: {}".format(endpoint))
-
+        log.debug("Uploading image '{}' to compute".format(self._image.path))
        parse_results = urllib.parse.urlparse(endpoint)
        network_manager = self._controller.getHttpClient().getNetworkManager()
        client = HTTPClient.fromUrl(endpoint, network_manager=network_manager)
        # We don't retry connection as in case of fail we try direct file upload
        client.setMaxRetryConnection(0)
-        client.createHTTPQuery(
-            'POST', parse_results.path, self._checkIfSuccessfulCallback, body=pathlib.Path(self._image.path),
-            progressText="Uploading {}".format(self._image.filename), timeout=None, prefix="")
+        client.createHTTPQuery('POST', parse_results.path, self._checkIfSuccessfulCallback, body=pathlib.Path(self._image.path),
+                               context={"image_path": self._image.path}, progressText="Uploading {}".format(self._image.filename), timeout=None, prefix="")

    def _fileUploadToController(self):
-        log.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.debug("Uploading image '{}' to controller".format(self._image.path))
+        self._controller.postCompute(self._getComputePath(), self._compute_id, self._callback, body=pathlib.Path(self._image.path),
+                                     context={"image_path": self._image.path}, progressText="Uploading {}".format(self._image.filename), timeout=None)
--- a/gns3/items/drawing_item.py
+++ b/gns3/items/drawing_item.py
@@ -41,8 +41,10 @@ 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._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)
@@ -64,6 +66,8 @@ class DrawingItem:
        if rotation:
            self.setRotation(rotation)

+        self.setLocked(locked)
+
    def drawing_id(self):
        return self._id

@@ -81,13 +85,13 @@ class DrawingItem:
        """

        if error:
-            log.error("Error while setting up drawing: {}".format(result["message"]))
+            log.error("Error while creating drawing: {}".format(result["message"]))
            return False
        self._id = result["drawing_id"]
        self.updateDrawingCallback(result)

    def updateDrawing(self):
-        if self._id:
+        if self._id and not self.deleting() and self._project:
            self._project.put("/drawings/" + self._id, self.updateDrawingCallback, body=self.__json__(), showProgress=False)

    @qslot
@@ -101,10 +105,11 @@ class DrawingItem:
        """

        if error:
-            log.error("Error while setting up drawing: {}".format(result["message"]))
+            log.error("Error while updating drawing: {}".format(result["message"]))
            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"])
@@ -148,6 +153,7 @@ class DrawingItem:
            "x": int(self.pos().x()),
            "y": int(self.pos().y()),
            "z": int(self.zValue()),
+            "locked": self._locked,
            "rotation": int(self.rotation())
        }
        svg = self.toSvg()
@@ -157,21 +163,39 @@ 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 drawing being deleted
+        """
+
+        return self._deleting
+
+    def setDeleting(self):
+        """
+        Mark this drawing as being deleted
+        """
+
+        self._deleting = True

    def delete(self, skip_controller=False):
        """
@@ -180,6 +204,7 @@ class DrawingItem:
        :param skip_controller: Do not replicate change on the controller (usefull when it's already deleted on controller)
        """

+        self.setDeleting()
        self.scene().removeItem(self)
        from ..topology import Topology
        Topology.instance().removeDrawing(self)
@@ -187,14 +212,13 @@ 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 = 75
+
+        if change == QtWidgets.QGraphicsItem.ItemPositionChange and self.isActive() and self._main_window.uiSnapToGridAction.isChecked():
+            grid_size = self._graphics_view.drawingGridSize()
            mid_x = self.boundingRect().width() / 2
-            tmp_x = (GRID_SIZE * round((self.x() + mid_x) / GRID_SIZE)) - mid_x
+            value.setX((grid_size * round((value.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)
+            value.setY((grid_size * round((value.y()+mid_y)/grid_size)) - mid_y)

        if change == QtWidgets.QGraphicsItem.ItemSelectedChange:
            if not value:
--- a/gns3/items/ellipse_item.py
+++ b/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
--- a/gns3/items/ethernet_link_item.py
+++ b/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)
@@ -106,7 +113,7 @@ class EthernetLinkItem(LinkItem):
        """

        QtWidgets.QGraphicsPathItem.paint(self, painter, option, widget)
-        if not self._adding_flag and self._settings["draw_link_status_points"]:
+        if not self._adding_flag:

            # points disappears if nodes are too close to each others.
            if self.length < 100:
@@ -141,17 +148,19 @@ 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()

-            painter.drawPoint(point1)
+            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:
                # link or port is suspended
@@ -182,16 +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()

-            painter.drawPoint(point2)
+            if self._settings["draw_link_status_points"] and self.pen().style() != QtCore.Qt.NoPen:
+                painter.drawPoint(point2)

        self._drawSymbol()
--- a/gns3/items/image_item.py
+++ b/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)
--- a/gns3/items/label_item.py
+++ b/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

@@ -174,27 +170,12 @@ class NoteItem(QtWidgets.QGraphicsTextItem):
        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()
--- a/gns3/items/line_item.py
+++ b/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)
--- a/gns3/items/link_item.py
+++ b/gns3/items/link_item.py
@@ -21,10 +21,12 @@ Link items are graphical representation of a link on the QGraphicsScene
 """

 import math
-from ..qt import QtCore, QtGui, QtWidgets, QtSvg, qslot
+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,6 +138,21 @@ 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
@@ -222,14 +240,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 +266,31 @@ 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)

+        # 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,14 +302,23 @@ 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)

+    def contextMenuEvent(self, event):
+        """
+        Handles all context menu events.
+
+        :param event: QContextMenuEvent instance
+        """
+
+        if not sip_is_deleted(self):
            # create the contextual menu
            self.setAcceptHoverEvents(False)
            menu = QtWidgets.QMenu()
--- a/gns3/items/logo_item.py
+++ b/gns3/items/logo_item.py
@@ -0,0 +1,136 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2018 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+import urllib.parse
+
+from ..qt import QtCore, QtGui, QtWidgets, QtSvg
+from ..qt.qimage_svg_renderer import QImageSvgRenderer
+from ..controller import Controller
+
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class LogoItem(QtSvg.QGraphicsSvgItem):
+    """
+    Margin for the logo
+    """
+    MARGIN = 20
+
+    """
+    Logo for the scene.
+
+    :param logo_path: Path to the logo (remote)
+    :param logo_url: URL which needs to be open user clicks on the logo
+    :param project: Current project
+    """
+
+    def __init__(self, logo_path, logo_url, project):
+        super().__init__()
+
+        self._logo_path = logo_path
+        self._logo_url = logo_url
+        self._project = project
+
+        # Temporary symbol during loading
+        renderer = QImageSvgRenderer(":/icons/reload.svg")
+        renderer.setObjectName("symbol_loading")
+        self.setSharedRenderer(renderer)
+
+        effect = QtWidgets.QGraphicsColorizeEffect()
+        effect.setColor(QtGui.QColor("black"))
+        effect.setStrength(0.8)
+        self.setGraphicsEffect(effect)
+        self.graphicsEffect().setEnabled(False)
+
+        # set graphical settings for this item
+        self.setFlag(QtWidgets.QGraphicsItem.ItemIsFocusable)
+        self.setFlag(QtWidgets.QGraphicsItem.ItemSendsGeometryChanges)
+        self.setAcceptHoverEvents(True)
+
+        from ..main_window import MainWindow
+        self._main_window = MainWindow.instance()
+        self._settings = self._main_window.uiGraphicsView.settings()
+
+        self.updatePosition()
+
+        self._main_window.uiGraphicsView.viewport().installEventFilter(self)
+
+        remote_file = urllib.parse.quote('project-files/images/{}'.format(logo_path))
+
+        Controller.instance().getStatic(
+            '/projects/{}/files/{}'.format(project.id(), remote_file),
+            self.updateImage
+        )
+
+        # make it the last one
+        self.setZValue(-2)
+
+    def eventFilter(self, source, event):
+        if event.type() == QtCore.QEvent.Paint:
+            self.updatePosition()
+        return QtWidgets.QWidget.eventFilter(self, source, event)
+
+
+    def updateImage(self, local_path):
+        renderer = QImageSvgRenderer(local_path)
+        renderer.setObjectName("project_logo")
+        self.setSharedRenderer(renderer)
+
+
+    def updatePosition(self):
+        """
+        Updates position to be located in the right bottom corner
+        """
+        logo_rect = self.boundingRect()
+        width = self._main_window.uiGraphicsView.viewport().width()
+        height = self._main_window.uiGraphicsView.viewport().height()
+        rect = self._main_window.uiGraphicsView.mapToScene(QtCore.QRect(0, 0, width, height)).boundingRect()
+        x = rect.x() + rect.width() - self.MARGIN - logo_rect.width()
+        y = rect.y() + rect.height() - self.MARGIN - logo_rect.height()
+
+        # update only when changes
+        if [int(self.x()), int(self.y())] != [int(x), int(y)]:
+            self.setX(x)
+            self.setY(y)
+            self.update()
+
+    def hoverEnterEvent(self, event):
+        """
+        Handles all hover enter events for this item.
+
+        :param event: QGraphicsSceneHoverEvent instance
+        """
+
+        if self._logo_url is not None:
+            self.graphicsEffect().setEnabled(True)
+
+    def hoverLeaveEvent(self, event):
+        """
+        Handles all hover leave events for this item.
+
+        :param event: QGraphicsSceneHoverEvent instance
+        """
+
+        self.graphicsEffect().setEnabled(False)
+
+    def mousePressEvent(self, event):
+        url = QtCore.QUrl(self._logo_url)
+        if not QtGui.QDesktopServices.openUrl(url):
+            QtWidgets.QMessageBox.warning(self, 'Open Url', 'Could not open url')
--- a/gns3/items/node_item.py
+++ b/gns3/items/node_item.py
@@ -19,11 +19,11 @@
 Graphical representation of a node on the QGraphicsScene.
 """

-import sip
+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

@@ -41,7 +41,6 @@ class NodeItem(QtSvg.QGraphicsSvgItem):
    """

    show_layer = False
-    GRID_SIZE = 75

    def __init__(self, node):
        super().__init__()
@@ -51,6 +50,7 @@ class NodeItem(QtSvg.QGraphicsSvgItem):
        # link items connected to this node item.
        self._links = []
        self._symbol = None
+        self._locked = False

        # says if the attached node has been initialized
        # by the server.
@@ -60,7 +60,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")
@@ -80,6 +79,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)
@@ -100,24 +103,16 @@ 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):
-        mid_x = self.boundingRect().width() / 2
-        x = (self.GRID_SIZE * round((self.x() + mid_x) / self.GRID_SIZE)) - mid_x
-        mid_y = self.boundingRect().height() / 2
-        y = (self.GRID_SIZE * round((self.y() + mid_y) / self.GRID_SIZE)) - mid_y
-        self.setPos(x, y)
-
    def updateNode(self):
        """
        Sync change to the node
        """
+
        self._node.setGraphics(self)

    @qslot
@@ -143,9 +138,14 @@ class NodeItem(QtSvg.QGraphicsSvgItem):

    @qslot
    def _symbolLoadedCallback(self, path, *args):
+
        renderer = QImageSvgRenderer(path, fallback=":/icons/cancel.svg")
        renderer.setObjectName(path)
        self.setSharedRenderer(renderer)
+        if self._settings["limit_size_node_symbols"] is True and renderer.defaultSize().height() > 80:
+            # resize the SVG
+            renderer.resize(80)
+            self.setSharedRenderer(renderer)
        if self._node.settings().get("symbol") != self._symbol:
            self.updateNode()
        if not self._initialized:
@@ -263,7 +263,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
@@ -356,7 +356,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()
@@ -364,7 +364,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
@@ -373,15 +373,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.

@@ -429,7 +436,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):
@@ -457,10 +467,11 @@ class NodeItem(QtSvg.QGraphicsSvgItem):
        """

        if change == QtWidgets.QGraphicsItem.ItemPositionChange and self.isActive() and self._main_window.uiSnapToGridAction.isChecked():
+            grid_size = self._main_window.uiGraphicsView.nodeGridSize()
            mid_x = self.boundingRect().width() / 2
-            value.setX((self.GRID_SIZE * round((value.x() + mid_x) / self.GRID_SIZE)) - mid_x)
+            value.setX((grid_size * round((value.x() + mid_x) / grid_size)) - mid_x)
            mid_y = self.boundingRect().height() / 2
-            value.setY((self.GRID_SIZE * round((value.y() + mid_y) / self.GRID_SIZE)) - mid_y)
+            value.setY((grid_size * round((value.y() + mid_y) / grid_size)) - mid_y)

        # dynamically change the renderer when this node item is selected/unselected.
        if change == QtWidgets.QGraphicsItem.ItemSelectedChange:
@@ -514,20 +525,31 @@ class NodeItem(QtSvg.QGraphicsSvgItem):
        """

        super().setZValue(value)
-        if self.zValue() < 0:
-            self.setFlag(self.ItemIsSelectable, False)
+        for link in self._links:
+            link.adjust()
+
+    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):
        """
--- a/gns3/items/rectangle_item.py
+++ b/gns3/items/rectangle_item.py
@@ -46,13 +46,6 @@ class RectangleItem(QtWidgets.QGraphicsRectItem, 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
--- a/gns3/items/serial_link_item.py
+++ b/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)
@@ -107,7 +113,7 @@ class SerialLinkItem(LinkItem):

        QtWidgets.QGraphicsPathItem.paint(self, painter, option, widget)

-        if not self._adding_flag and self._settings["draw_link_status_points"]:
+        if not self._adding_flag:

            # points disappears if nodes are too close to each others.
            if self.length < 80:
@@ -130,17 +136,19 @@ 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()

-            painter.drawPoint(self.source_point)
+            if self._settings["draw_link_status_points"] and self.pen().style() != QtCore.Qt.NoPen:
+                painter.drawPoint(self.source_point)

            # destination point color
            if self._link.suspended() or self._destination_port.status() == Port.suspended:
@@ -160,16 +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()

-            painter.drawPoint(self.destination_point)
+            if self._settings["draw_link_status_points"] and self.pen().style() != QtCore.Qt.NoPen:
+                painter.drawPoint(self.destination_point)

        self._drawSymbol()
--- a/gns3/items/shape_item.py
+++ b/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,8 +167,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():
            self._graphics_view.setCursor(QtCore.Qt.ArrowCursor)

    def fromSvg(self, svg):
--- a/gns3/items/text_item.py
+++ b/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
--- a/gns3/link.py
+++ b/gns3/link.py
@@ -19,12 +19,11 @@
 Manages and stores everything needed for a connection between 2 devices.
 """

-import os
 import re
-import sip
+from .qt import sip
 import uuid

-from .qt import QtCore, QtWidgets
+from .qt import QtCore
 from .controller import Controller


@@ -76,8 +75,11 @@ class Link(QtCore.QObject):
        self._destination_label = None
        self._link_id = link_id
        self._capturing = False
+        self._deleting = False
        self._capture_file_path = None
        self._capture_file = None
+        self._response_stream = None
+        self._capture_compute_id = None
        self._initialized = False
        self._filters = {}
        self._suspend = False
@@ -88,7 +90,7 @@ class Link(QtCore.QObject):
        self._creator = False

        self._nodes = []
-
+        self._link_style = {}
        self._source_node.addLink(self)
        self._destination_node.addLink(self)

@@ -102,33 +104,38 @@ 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)
+                self._response_stream = Controller.instance().get("/projects/{project_id}/links/{link_id}/pcap".format(project_id=self.project().id(), link_id=self._link_id),
+                                                                  None,
+                                                                  showProgress=False,
+                                                                  downloadProgressCallback=self._downloadPcapProgress,
+                                                                  ignoreErrors=True,  # If something is wrong avoid disconnect us from server
+                                                                  timeout=None)
+            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)
@@ -158,7 +165,7 @@ class Link(QtCore.QObject):
            self._updateLabels()

    def update(self):
-        if not self._link_id:
+        if not self._link_id or self.deleting():
            return
        body = self._prepareParams()
        Controller.instance().put("/projects/{project_id}/links/{link_id}".format(project_id=self._source_node.project().id(), link_id=self._link_id), self.updateLinkCallback, body=body)
@@ -171,7 +178,7 @@ class Link(QtCore.QObject):

    def updateLinkCallback(self, result, error=False, *args, **kwargs):
        if error:
-            QtWidgets.QMessageBox.warning(None, "Update link", "Error while updating link: {}".format(result["message"]))
+            log.warning("Error while updating link: {}".format(result["message"]))
            return
        self._parseResponse(result)

@@ -211,6 +218,7 @@ class Link(QtCore.QObject):
                }
            ],
            "filters": self._filters,
+            "link_style": self._link_style,
            "suspend": self._suspend
        }
        if self._source_port.label():
@@ -221,7 +229,7 @@ class Link(QtCore.QObject):

    def _linkCreatedCallback(self, result, error=False, **kwargs):
        if error:
-            QtWidgets.QMessageBox.warning(None, "Create link", "Error while creating link: {}".format(result["message"]))
+            log.warning("Error while creating link: {}".format(result["message"]))
            self.deleteLink(skip_controller=True)
            return

@@ -244,6 +252,19 @@ class Link(QtCore.QObject):
    def link_id(self):
        return self._link_id

+    def deleting(self):
+        """
+        Is the link being deleted
+        """
+        return self._deleting
+
+    def setDeleting(self):
+        """
+        Mark this link as being deleted
+        """
+
+        self._deleting = True
+
    def capturing(self):
        """
        Is a capture running on the link?
@@ -291,7 +312,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):
        """
@@ -306,8 +327,10 @@ class Link(QtCore.QObject):
        if skip_controller:
            self._linkDeletedCallback({})
        else:
+            self.setDeleting()
            Controller.instance().delete("/projects/{project_id}/links/{link_id}".format(project_id=self.project().id(),
-                                                                                         link_id=self._link_id), self._linkDeletedCallback)
+                                                                                         link_id=self._link_id),
+                                                                                         self._linkDeletedCallback)

    def _linkDeletedCallback(self, result, error=False, **kwargs):
        """
@@ -332,62 +355,57 @@ class Link(QtCore.QObject):
            "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}/start_capture".format(project_id=self.project().id(), link_id=self._link_id),
+                                   self._startCaptureCallback,
+                                   body=data)

    def _startCaptureCallback(self, result, error=False, **kwargs):
        if error:
-            log.error("Error while starting capture on link: {}".format(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}/stop_capture".format(project_id=self.project().id(),
+                                                                                                link_id=self._link_id),
+                                                                                                self._stopCaptureCallback)
+

    def _stopCaptureCallback(self, result, error=False, **kwargs):
        if error:
-            log.error("Error while stopping capture on link: {}".format(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):
        """
@@ -455,3 +473,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
--- a/gns3/local_config.py
+++ b/gns3/local_config.py
@@ -23,10 +23,11 @@ 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
+from .local_server_config import LocalServerConfig
+from .settings import LOCAL_SERVER_SETTINGS

 import logging
 log = logging.getLogger(__name__)
@@ -39,38 +40,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 +89,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("Server", LOCAL_SERVER_SETTINGS)
+                    settings["path"] = ""
+                    settings["ubridge_path"] = ""
+                    LocalServerConfig.instance().saveSettings("Server", settings)
+                else:
+                    # create a new config
+                    with open(self._config_file, "w", encoding="utf-8") as f:
+                        json.dump({"version": __version__, "type": "settings"}, f)
            except OSError as e:
                log.error("Could not create the config file {}: {}".format(self._config_file, e))

@@ -136,47 +133,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 +166,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 +177,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
@@ -216,28 +185,31 @@ class LocalConfig(QtCore.QObject):
        # settings from 1.6.1 with 1.5.1 you will have an error
        if "version" in self._settings:
            if parse_version(self._settings["version"])[:2] > parse_version(__version__)[:2]:
-                QtWidgets.QApplication(sys.argv)  # We need to create an application because settings are loaded before Qt init
-                QtWidgets.QMessageBox.critical(None, "Version error", "Your settings are for version {} of GNS3. You cannot use a previous version of GNS3 without risking losing data. If you want to reset delete the settings in {}".format(self._settings["version"], self.configDirectory()))
+                app = QtWidgets.QApplication(sys.argv)  # We need to create an application because settings are loaded before Qt init
+                error_message = "Settings are for version {} of GNS3. It is not possible to use a previous version of GNS3 without risking losing data. Delete the settings in '{}' to start GNS3".format(self._settings["version"], self.configDirectory())
+                QtWidgets.QMessageBox.critical(False, "Version error", error_message)
                # Exit immediately not clean but we want to avoid any side effect that could corrupt the file
+                QtCore.QTimer.singleShot(0, app.quit)
+                app.exec_()
                sys.exit(1)

        if "version" not in self._settings or parse_version(self._settings["version"]) < parse_version("1.4.0alpha1"):

-            servers = self._settings.get("Servers", {})
+             servers = self._settings.get("Servers", {})

-            if "LocalServer" in self._settings:
+             if "LocalServer" in self._settings:
                servers["local_server"] = copy.copy(self._settings["LocalServer"])

-                # We migrate the server binary for OSX due to the change from py2app to CX freeze
+                 # We migrate the server binary for OSX due to the change from py2app to CX freeze
                if servers["local_server"]["path"] == "/Applications/GNS3.app/Contents/Resources/server/Contents/MacOS/gns3server":
                    servers["local_server"]["path"] = "gns3server"

-            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
@@ -250,7 +222,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
@@ -261,7 +233,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:
@@ -309,25 +281,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", "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):

@@ -483,8 +436,7 @@ class LocalConfig(QtCore.QObject):
        """

        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
@@ -492,6 +444,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():
        """
@@ -520,7 +488,7 @@ class LocalConfig(QtCore.QObject):
                    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:
--- a/gns3/local_server.py
+++ b/gns3/local_server.py
@@ -31,12 +31,11 @@ import subprocess


 from gns3.qt import QtWidgets, QtCore, qslot
-from gns3.settings import LOCAL_SERVER_SETTINGS
+from gns3.settings import LOCAL_SERVER_SETTINGS, DEFAULT_LOCAL_SERVER_HOST
 from gns3.local_config import LocalConfig
 from gns3.local_server_config import LocalServerConfig
 from gns3.utils.wait_for_connection_worker import WaitForConnectionWorker
 from gns3.utils.progress_dialog import ProgressDialog
-from gns3.utils.http import getSynchronous
 from gns3.utils.sudo import sudo
 from gns3.http_client import HTTPClient
 from gns3.controller import Controller
@@ -124,9 +123,14 @@ class LocalServer(QtCore.QObject):
        return self._parent

    def _checkWindowsService(self, service_name):
-        import pywintypes
-        import win32service
-        import win32serviceutil
+
+        try:
+            import pywintypes
+            import win32service
+            import win32serviceutil
+        except ImportError as e:
+            log.error("Could not check if the {} service is running: {}".format(service_name, e))
+            return

        try:
            if win32serviceutil.QueryServiceStatus(service_name, None)[1] != win32service.SERVICE_RUNNING:
@@ -136,6 +140,7 @@ class LocalServer(QtCore.QObject):
                return False
            else:
                log.error("Could not check if the {} service is running: {}".format(service_name, e.strerror))
+
        return True

    def _checkUbridgePermissions(self):
@@ -241,6 +246,9 @@ 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_LOCAL_SERVER_HOST
        old_settings = copy.copy(self._settings)
        if not self._settings:
            self._settings = new_settings
@@ -262,7 +270,7 @@ 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)
@@ -308,9 +316,9 @@ 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():
@@ -355,7 +363,6 @@ class LocalServer(QtCore.QObject):
        self._server_started_by_me = True
        self._http_client = HTTPClient(self._settings)
        Controller.instance().setHttpClient(self._http_client)
-
        return True

    def initLocalServer(self):
@@ -365,17 +372,19 @@ class LocalServer(QtCore.QObject):

        self._checkUbridgePermissions()

-        if sys.platform.startswith('win'):
-            if not self._checkWindowsService("npf") and not self._checkWindowsService("npcap"):
-                QtWidgets.QMessageBox.critical(self.parent(), "Error", "The NPF or NPCAP service is not installed, please install Winpcap or Npcap and reboot.")
-                return False
+        if sys.platform.startswith("win"):
+            import pywintypes
+            try:
+                if not self._checkWindowsService("npf") and not self._checkWindowsService("npcap"):
+                    log.warning("The NPF or NPCAP service is not installed, please install Winpcap or Npcap and reboot.")
+            except pywintypes.error as e:
+                log.warning("Could not check if the NPF or Npcap service is running: {}".format(e.strerror))

        self._port = self._settings["port"]
-
        # check the local server path
        local_server_path = self.localServerPath()
        if not local_server_path:
-            log.warn("No local server is configured")
+            log.warning("No local server is configured")
            return False
        if not os.path.isfile(local_server_path):
            QtWidgets.QMessageBox.critical(self.parent(), "Local server", "Could not find local server {}".format(local_server_path))
@@ -462,7 +471,7 @@ class LocalServer(QtCore.QObject):
                except FileNotFoundError:
                    pass
                except OSError as e:
-                    log.warn("could not delete server log file {}: {}".format(logpath, e))
+                    log.warning("could not delete server log file {}: {}".format(logpath, e))
            command += ' --log="{}" --pid="{}"'.format(logpath, self._pid_path())

        log.debug("Starting local server process with {}".format(command))
@@ -512,9 +521,7 @@ 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"])
-
+        status, json_data = HTTPClient(self._settings).getSynchronous("GET", "/version")
        if status == 401:  # Auth issue that need to be solved later
            return True
        elif json_data is None:
--- a/gns3/local_server_config.py
+++ b/gns3/local_server_config.py
@@ -138,6 +138,18 @@ class LocalServerConfig:
        if changed:
            self.writeConfig()

+    def deleteSetting(self, section, name):
+        """
+        Delete a specific setting in a given section.
+
+        :param section: section name
+        :param name: setting name to delete
+        """
+
+        if section in self._config and name in self._config[section]:
+            del self._config[section][name]
+            self.writeConfig()
+
    @staticmethod
    def instance():
        """
--- a/gns3/logger.py
+++ b/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)))

--- a/gns3/main.py
+++ b/gns3/main.py
@@ -90,13 +90,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 +118,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="?")
@@ -137,15 +140,13 @@ def main():
        # 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, 'vpcs'))
+                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", "")
@@ -257,8 +258,7 @@ 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)))

    # 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)
@@ -267,7 +267,10 @@ def main():
    # issue when people run GNS3 from the .dmg
    if sys.platform.startswith("darwin") and hasattr(sys, "frozen"):
        if not os.path.realpath(sys.executable).startswith("/Applications"):
-            QtWidgets.QMessageBox.critical(None, "Error", "You need to copy GNS3 in your /Applications folder before using it.")
+            error_message = "GNS3.app must be moved to the '/Applications' folder before it can be used"
+            QtWidgets.QMessageBox.critical(False, "Loading error", error_message)
+            QtCore.QTimer.singleShot(0, app.quit)
+            app.exec_()
            sys.exit(1)

    global mainwindow
@@ -291,7 +294,6 @@ def main():
    mainwindow.show()

    exit_code = app.exec_()
-
    signal.signal(signal.SIGINT, orig_sigint)
    signal.signal(signal.SIGTERM, orig_sigterm)

@@ -300,7 +302,7 @@ def main():
    # We force deleting the app object otherwise it's segfault on Fedora
    del app
    # We force a full garbage collect before exit
-    # for unknow reason otherwise Qt Segfault on OSX in some
+    # for unknown reason otherwise Qt Segfault on OSX in some
    # conditions
    import gc
    gc.collect()
--- a/gns3/main_window.py
+++ b/gns3/main_window.py
@@ -42,18 +42,20 @@ from .dialogs.edit_project_dialog import EditProjectDialog
 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,24 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
        self._settings = {}

        self.setupUi(self)
+        self.setUnifiedTitleAndToolBarOnMac(True)
+
+        # These widgets will be disabled when no project is 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._notif_dialog = NotifDialog(self)
        # Setup logger
@@ -109,12 +129,13 @@ 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.restoreGeometry(QtCore.QByteArray().fromBase64(self._settings["geometry"].encode()))
@@ -138,6 +159,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):
@@ -166,32 +190,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 +207,7 @@ 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.uiSaveProjectAsAction.triggered.connect(self._saveProjectAsActionSlot)
        self.uiExportProjectAction.triggered.connect(self._exportProjectActionSlot)
        self.uiImportProjectAction.triggered.connect(self._importProjectActionSlot)
@@ -229,9 +233,10 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
        self.uiShowPortNamesAction.triggered.connect(self._showPortNamesActionSlot)
        self.uiShowGridAction.triggered.connect(self._showGridActionSlot)
        self.uiSnapToGridAction.triggered.connect(self._snapToGridActionSlot)
+        self.uiLockAllAction.triggered.connect(self._lockActionSlot)

        # tool menu connections
-        self.uiWebInterfaceAction.triggered.connect(self._openWebInterfaceActionSlot)
+        self.uiWebUIAction.triggered.connect(self._openWebInterfaceActionSlot)

        # control menu connections
        self.uiStartAllAction.triggered.connect(self._startAllActionSlot)
@@ -270,8 +275,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 +320,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 = "{}/static/web-ui/bundled".format(base_url)
+            QtGui.QDesktopServices.openUrl(QtCore.QUrl(webui_url))

    def _showGridActionSlot(self):
        """
@@ -342,6 +349,23 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
            project.setSnapToGrid(self.uiSnapToGridAction.isChecked())
            project.update()

+    def _lockActionSlot(self):
+        """
+        Called when user click on the lock menu item
+        :return: None
+        """
+
+        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 analyticsClient(self):
        """
        Return the analytics client
@@ -361,46 +385,36 @@ 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()
-
    @qslot
    def openApplianceActionSlot(self, *args):
        """
        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,
+        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 +425,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(),
+            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):
        """
@@ -506,17 +524,17 @@ 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())

        # No projects
        if Topology.instance().project() is None:
@@ -536,7 +554,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 +733,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 +742,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 +803,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 +819,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 +834,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,6 +849,12 @@ 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()
@@ -886,7 +929,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):
        """
@@ -908,9 +951,7 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
            setup_wizard.show()
            res = setup_wizard.exec_()
            # start and connect to the local server if needed
-            LocalServer.instance().localServerAutoStartIfRequire()
-            if res:
-                self._newApplianceActionSlot()
+            LocalServer.instance().localServerAutoStartIfRequired()

    def _aboutQtActionSlot(self):
        """
@@ -1032,11 +1073,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):
        """
@@ -1102,6 +1143,7 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
        self._settings["state"] = bytes(self.saveState().toBase64()).decode()
        self.setSettings(self._settings)

+        Controller.instance().stopListenNotifications()
        server = LocalServer.instance()
        server.stopLocalServer(wait=True)

@@ -1161,8 +1203,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"))
@@ -1178,7 +1221,7 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
            self._setupWizardActionSlot()
        else:
            # start and connect to the local server if needed
-            LocalServer.instance().localServerAutoStartIfRequire()
+            LocalServer.instance().localServerAutoStartIfRequired()
            if self._open_file_at_startup:
                self.loadPath(self._open_file_at_startup)
                self._open_file_at_startup = None
@@ -1307,7 +1350,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
@@ -1352,14 +1403,16 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
        """
        Slot called to import a portable 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,
+        path, _ = QtWidgets.QFileDialog.getOpenFileName(self, "Open portable 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:
--- a/gns3/modules/init.py
+++ b/gns3/modules/init.py
@@ -19,9 +19,12 @@ from gns3.modules.builtin import Builtin
 from gns3.modules.dynamips import Dynamips
 from gns3.modules.iou import IOU
 from gns3.modules.vpcs import VPCS
+from gns3.modules.traceng import TraceNG
 from gns3.modules.virtualbox import VirtualBox
 from gns3.modules.qemu import Qemu
 from gns3.modules.vmware import VMware
 from gns3.modules.docker import Docker

+#MODULES = [Builtin, VPCS, Dynamips, IOU, Qemu, VirtualBox, VMware, Docker, TraceNG]
+#FIXME: deactivate TraceNG module
 MODULES = [Builtin, VPCS, Dynamips, IOU, Qemu, VirtualBox, VMware, Docker]
--- a/gns3/modules/builtin/init.py
+++ b/gns3/modules/builtin/init.py
@@ -21,6 +21,7 @@ Built-in module implementation.

 from gns3.qt import QtWidgets
 from gns3.local_config import LocalConfig
+from gns3.local_server_config import LocalServerConfig

 from ..module import Module
 from .cloud import Cloud
@@ -29,13 +30,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 +44,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 +53,15 @@ class Builtin(Module):

        LocalConfig.instance().saveSectionSettings(self.__class__.__name__, self._settings)

+        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 +69,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 +124,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 +148,10 @@ class Builtin(Module):
        if not hasattr(Builtin, "_instance"):
            Builtin._instance = Builtin()
        return Builtin._instance
+
+    def __str__(self):
+        """
+        Returns the module name.
+        """
+
+        return "builtin"
--- a/gns3/modules/builtin/atm_switch.py
+++ b/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 server 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():
        """
--- a/gns3/modules/builtin/cloud.py
+++ b/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,32 @@ 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": [],
+                                "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 +70,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 +113,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:
@@ -129,11 +161,6 @@ Device run on {host}

        return ":/symbols/cloud.svg"

-    @staticmethod
-    def symbolName():
-
-        return "Cloud"
-
    @staticmethod
    def categories():
        """
--- a/gns3/modules/builtin/dialogs/cloud_wizard.py
+++ b/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
    """
@@ -51,7 +49,6 @@ class CloudWizard(VMWizard, Ui_CloudNodeWizard):

        settings = {"name": self.uiNameLineEdit.text(),
                    "symbol": ":/symbols/cloud.svg",
-                    "category": Node.end_devices,
-                    "server": self._compute_id}
+                    "compute_id": self._compute_id}

        return settings
--- a/gns3/modules/builtin/dialogs/ethernet_hub_wizard.py
+++ b/gns3/modules/builtin/dialogs/ethernet_hub_wizard.py
@@ -24,13 +24,12 @@ from gns3.node import Node
 from gns3.dialogs.vm_wizard import VMWizard

 from ..ui.ethernet_hub_wizard_ui import Ui_EthernetHubWizard
-from .. import Builtin


 class EthernetHubWizard(VMWizard, Ui_EthernetHubWizard):

    """
-    Wizard to create an Ethernet hub template.
+    Wizard to create an Ethernet hub.

    :param parent: parent widget
    """
@@ -57,7 +56,7 @@ class EthernetHubWizard(VMWizard, Ui_EthernetHubWizard):
        settings = {"name": self.uiNameLineEdit.text(),
                    "symbol": ":/symbols/hub.svg",
                    "category": Node.switches,
-                    "server": self._compute_id,
+                    "compute_id": self._compute_id,
                    "ports_mapping": ports}

        return settings
--- a/gns3/modules/builtin/dialogs/ethernet_switch_wizard.py
+++ b/gns3/modules/builtin/dialogs/ethernet_switch_wizard.py
@@ -24,13 +24,12 @@ from gns3.node import Node
 from gns3.dialogs.vm_wizard import VMWizard

 from ..ui.ethernet_switch_wizard_ui import Ui_EthernetSwitchWizard
-from .. import Builtin


 class EthernetSwitchWizard(VMWizard, Ui_EthernetSwitchWizard):

    """
-    Wizard to create an Ethernet switch template.
+    Wizard to create an Ethernet switch.

    :param parent: parent widget
    """
@@ -60,7 +59,7 @@ class EthernetSwitchWizard(VMWizard, Ui_EthernetSwitchWizard):
        settings = {"name": self.uiNameLineEdit.text(),
                    "symbol": ":/symbols/ethernet_switch.svg",
                    "category": Node.switches,
-                    "server": self._compute_id,
+                    "compute_id": self._compute_id,
                    "ports_mapping": ports}

        return settings
--- a/gns3/modules/builtin/ethernet_hub.py
+++ b/gns3/modules/builtin/ethernet_hub.py
@@ -29,6 +29,7 @@ class EthernetHub(Node):
    :param server: GNS3 server instance
    :param project: Project instance
    """
+
    URL_PREFIX = "ethernet_hub"

    def __init__(self, module, server, project):
@@ -39,37 +40,6 @@ class EthernetHub(Node):
        self._always_on = True
        self.settings().update({"ports_mapping": []})

-    def _createCallback(self, result):
-        """
-        Callback for create.
-
-        :param result: server response (dict)
-        """
-        self.settings()["ports_mapping"] = result["ports_mapping"]
-
-    def update(self, new_settings):
-        """
-        Updates the settings for this Ethernet hub.
-
-        :param new_settings: settings dictionary
-        """
-
-        params = {}
-        if "name" in new_settings:
-            params["name"] = new_settings["name"]
-        if "ports_mapping" in new_settings:
-            params["ports_mapping"] = new_settings["ports_mapping"]
-        if params:
-            self._update(params)
-
-    def _updateCallback(self, result):
-        """
-        Callback for update.
-
-        :param result: server response
-        """
-        self.settings()["ports_mapping"] = result["ports_mapping"]
-
    def info(self):
        """
        Returns information about this Ethernet hub.
@@ -78,13 +48,13 @@ class EthernetHub(Node):
        """

        info = """Ethernet hub {name} is always-on
-  Local node ID is {id}
-  Server's node ID is {node_id}
-  Hub's server runs on {host}
+  Running on server {host} with port {port}
+  Local ID is {id} and server ID is {node_id}
 """.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 = ""
        for port in self._ports:
@@ -116,11 +86,6 @@ class EthernetHub(Node):

        return ":/symbols/hub.svg"

-    @staticmethod
-    def symbolName():
-
-        return "Ethernet hub"
-
    @staticmethod
    def categories():
        """
--- a/gns3/modules/builtin/ethernet_switch.py
+++ b/gns3/modules/builtin/ethernet_switch.py
@@ -22,7 +22,6 @@ log = logging.getLogger(__name__)


 class EthernetSwitch(Node):
-
    """
    Ethernet switch.

@@ -30,6 +29,7 @@ class EthernetSwitch(Node):
    :param server: GNS3 server instance
    :param project: Project instance
    """
+
    URL_PREFIX = "ethernet_switch"

    def __init__(self, module, server, project):
@@ -38,41 +38,7 @@ class EthernetSwitch(Node):
        # this is an always-on node
        self.setStatus(Node.started)
        self._always_on = True
-        self.settings().update({"ports_mapping": [], "console": None, "console_type": "telnet"})
-
-    def _createCallback(self, result):
-        """
-        Callback for create.
-
-        :param result: server response (dict)
-        """
-        self.settings()["ports_mapping"] = result["ports_mapping"]
-        self.settings()["console"] = result["console"]
-
-    def console(self):
-        return self.settings()["console"]
-
-    def update(self, new_settings):
-        """
-        Updates the settings for this Ethernet 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()["ports_mapping"] = result["ports_mapping"]
+        self.settings().update({"ports_mapping": [], "console_type": "none"})

    def info(self):
        """
@@ -82,13 +48,16 @@ class EthernetSwitch(Node):
        """

        info = """Ethernet switch {name} is always-on
-  Local node ID is {id}
-  Server's Node ID is {node_id}
-  Switch's server runs on {host}
+  Running on server {host} with port {port}
+  Local ID is {id} and server ID is {node_id}
+  Console is on port {console} and type is {console_type}
 """.format(name=self.name(),
           id=self.id(),
           node_id=self._node_id,
-           host=self.compute().name())
+           host=self.compute().name(),
+           port=self.compute().port(),
+           console=self._settings["console"],
+           console_type=self._settings["console_type"])

        port_info = ""
        for port in self._ports:
@@ -140,11 +109,6 @@ class EthernetSwitch(Node):

        return ":/symbols/ethernet_switch.svg"

-    @staticmethod
-    def symbolName():
-
-        return "Ethernet switch"
-
    @staticmethod
    def categories():
        """
--- a/gns3/modules/builtin/frame_relay_switch.py
+++ b/gns3/modules/builtin/frame_relay_switch.py
@@ -41,36 +41,6 @@ class FrameRelaySwitch(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 Frame Relay 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 Frame Relay switch.
@@ -79,14 +49,14 @@ class FrameRelaySwitch(Node):
        """

        info = """Frame relay 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 server ID is {node_id}
  Hardware is Dynamips emulated simple Frame relay 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 = ""
        for port in self._ports:
@@ -136,11 +106,6 @@ class FrameRelaySwitch(Node):

        return ":/symbols/frame_relay_switch.svg"

-    @staticmethod
-    def symbolName():
-
-        return "Frame Relay switch"
-
    @staticmethod
    def categories():
        """
--- a/gns3/modules/builtin/nat.py
+++ b/gns3/modules/builtin/nat.py
@@ -42,45 +42,6 @@ class Nat(Node):
        self._nat_settings = {}
        self.settings().update(self._nat_settings)

-    def interfaces(self):
-
-        return self._interfaces
-
-    def _createCallback(self, result, error=False, **kwargs):
-        """
-        Callback for create.
-
-        :param result: server response
-        """
-
-        if error:
-            log.error("Error while creating nat: {}".format(result["message"]))
-            return
-
-    def update(self, new_settings):
-        """
-        Updates the settings for this nat.
-
-        :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, error=False, **kwargs):
-        """
-        Callback for update.
-
-        :param result: server response
-        """
-        if error:
-            log.error("Error while creating nat: {}".format(result["message"]))
-            return
-
    def info(self):
        """
        Returns information about this nat.
@@ -88,11 +49,11 @@ class Nat(Node):
        :returns: formatted string
        """

-        info = """Nat device {name} is always-on
-This is a node for external connections
-Device run on {host}
+        info = """NAT node {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())

        port_info = ""
        for port in self._ports:
@@ -114,11 +75,6 @@ Device run on {host}

        return ":/symbols/cloud.svg"

-    @staticmethod
-    def symbolName():
-
-        return "Nat"
-
    @staticmethod
    def categories():
        """
--- a/gns3/modules/builtin/pages/atm_switch_configuration_page.py
+++ b/gns3/modules/builtin/pages/atm_switch_configuration_page.py
@@ -35,8 +35,8 @@ class ATMSwitchConfigurationPage(QtWidgets.QWidget, Ui_atmSwitchConfigPageWidget
        super().__init__()
        self.setupUi(self)
        self._mapping = {}
+        self._node = None

-        # connect slots
        self.uiAddPushButton.clicked.connect(self._addMappingSlot)
        self.uiDeletePushButton.clicked.connect(self._deleteMappingSlot)
        self.uiMappingTreeWidget.itemActivated.connect(self._mappingSelectedSlot)
--- a/gns3/modules/builtin/pages/builtin_preferences_page.py
+++ b/gns3/modules/builtin/pages/builtin_preferences_page.py
@@ -16,45 +16,69 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.

 """
-Configuration page for Built-in preferences.
+Configuration page for builtins preferences.
 """

 from gns3.qt import QtWidgets
+from gns3.utils.interfaces import interfaces
+
 from .. import Builtin
 from ..ui.builtin_preferences_page_ui import Ui_BuiltinPreferencesPageWidget
 from ..settings import BUILTIN_SETTINGS


 class BuiltinPreferencesPage(QtWidgets.QWidget, Ui_BuiltinPreferencesPageWidget):
-    """QWidget preference page for Built-in."""
+
+    """
+    QWidget preference page for builtins.
+    """

    def __init__(self):

        super().__init__()
        self.setupUi(self)
-
-        # connect signals
        self.uiRestoreDefaultsPushButton.clicked.connect(self._restoreDefaultsSlot)

    def _restoreDefaultsSlot(self):
-        """Slot to populate the page widgets with the default settings."""
+        """
+        Slot to populate the page widgets with the default settings.
+        """

        self._populateWidgets(BUILTIN_SETTINGS)

    def _populateWidgets(self, settings):
-        """Populates the widgets with the settings.
+        """
+        Populates the widgets with the settings.

-        :param settings: Built-in settings
+        :param settings: builtins settings
        """

+        self.uiNATInterfaceComboBox.clear()
+        self.uiNATInterfaceComboBox.addItem("")
+        for interface in interfaces():
+            self.uiNATInterfaceComboBox.addItem(interface["name"])
+
+        # load the default NAT interface
+        index = self.uiNATInterfaceComboBox.findText(settings["default_nat_interface"])
+        if index != -1:
+            self.uiNATInterfaceComboBox.setCurrentIndex(index)
+
    def loadPreferences(self):
-        """Loads Built-in preferences."""
+        """
+        Loads builtins preferences.
+        """

        builtin_settings = Builtin.instance().settings()
        self._populateWidgets(builtin_settings)

    def savePreferences(self):
-        """Saves Built-in preferences."""
+        """
+        Saves builtins preferences.
+        """

        new_settings = {}
+
+        # save the default NAT interface
+        default_nat_interface = self.uiNATInterfaceComboBox.currentText()
+        new_settings["default_nat_interface"] = default_nat_interface
        Builtin.instance().setSettings(new_settings)
--- a/gns3/modules/builtin/pages/cloud_configuration_page.py
+++ b/gns3/modules/builtin/pages/cloud_configuration_page.py
@@ -21,6 +21,7 @@ Configuration page for clouds.

 from gns3.qt import QtCore, QtGui, QtWidgets
 from gns3.dialogs.symbol_selection_dialog import SymbolSelectionDialog
+from ....dialogs.node_properties_dialog import ConfigurationError
 from gns3.controller import Controller
 from gns3.node import Node

@@ -67,10 +68,12 @@ class CloudConfigurationPage(QtWidgets.QWidget, Ui_cloudConfigPageWidget):
        self.uiAddUDPPushButton.clicked.connect(self._UDPAddSlot)
        self.uiDeleteUDPPushButton.clicked.connect(self._UDPDeleteSlot)

+        # connect other slots
        self.uiShowSpecialInterfacesCheckBox.stateChanged.connect(self._showSpecialInterfacesSlot)
        self.uiSymbolToolButton.clicked.connect(self._symbolBrowserSlot)
+        self.uiConsoleTypeComboBox.currentTextChanged.connect(self._consoleTypeChangedSlot)

-        # add an icon to warning button
+        # add an icon to the warning button
        icon = QtGui.QIcon.fromTheme("dialog-warning")
        if icon.isNull():
            icon = QtGui.QIcon(':/icons/dialog-warning.svg')
@@ -84,7 +87,10 @@ class CloudConfigurationPage(QtWidgets.QWidget, Ui_cloudConfigPageWidget):
        if self._node:
            self._interfaces = self._node.interfaces()
            self._loadNetworkInterfaces(self._interfaces)
-            self._node.updated_signal.disconnect(self._refreshInterfaces)
+            try:
+                self._node.updated_signal.disconnect(self._refreshInterfaces)
+            except (TypeError, RuntimeError):
+                pass  # was not connected

    def _EthernetChangedSlot(self):
        """
@@ -348,6 +354,9 @@ class CloudConfigurationPage(QtWidgets.QWidget, Ui_cloudConfigPageWidget):
            self.uiUDPNameLineEdit.setText("UDP tunnel {}".format(nb_tunnels + 1))

    def _showSpecialInterfacesSlot(self, state):
+        """
+        Shows special Ethernet interfaces.
+        """

        self.uiEthernetComboBox.clear()
        index = 0
@@ -374,6 +383,9 @@ class CloudConfigurationPage(QtWidgets.QWidget, Ui_cloudConfigPageWidget):
            self.uiSymbolLineEdit.setToolTip('<img src="{}"/>'.format(new_symbol_path))

    def _loadNetworkInterfaces(self, interfaces):
+        """
+        Loads Ethernet and TAP interfaces.
+        """

        self.uiEthernetComboBox.clear()
        index = 0
@@ -405,6 +417,25 @@ class CloudConfigurationPage(QtWidgets.QWidget, Ui_cloudConfigPageWidget):
            self._interfaces = result
            self._loadNetworkInterfaces(result)

+    def _consoleTypeChangedSlot(self, console_type):
+        """
+        Slot called when the console type has been changed.
+
+        :param console_type: console type
+        """
+
+        if console_type in ("http", "https"):
+            self.uiConsoleHttpPathLineEdit.setEnabled(True)
+        else:
+            self.uiConsoleHttpPathLineEdit.setEnabled(False)
+
+        if console_type != "none":
+            self.uiConsoleHostLineEdit.setEnabled(True)
+            self.uiConsolePortSpinBox.setEnabled(True)
+        else:
+            self.uiConsoleHostLineEdit.setEnabled(False)
+            self.uiConsolePortSpinBox.setEnabled(False)
+
    def loadSettings(self, settings, node=None, group=False):
        """
        Loads the cloud settings.
@@ -416,13 +447,18 @@ class CloudConfigurationPage(QtWidgets.QWidget, Ui_cloudConfigPageWidget):

        if not group:
            self.uiNameLineEdit.setText(settings["name"])
+            self.uiConsoleHostLineEdit.setText(settings["remote_console_host"])
+            self.uiConsolePortSpinBox.setValue(settings["remote_console_port"])
+            index = self.uiConsoleTypeComboBox.findText(settings["remote_console_type"])
+            if index != -1:
+                self.uiConsoleTypeComboBox.setCurrentIndex(index)
+            self.uiConsoleHttpPathLineEdit.setText(settings["remote_console_http_path"])
        else:
            self.uiNameLineEdit.setEnabled(False)

        if not node:
            # these are template settings

-            # rename the label from "Name" to "Template name"
            self.uiNameLabel.setText("Template name:")

            # load the default name format
@@ -437,7 +473,7 @@ class CloudConfigurationPage(QtWidgets.QWidget, Ui_cloudConfigPageWidget):
            if index != -1:
                self.uiCategoryComboBox.setCurrentIndex(index)

-            Controller.instance().getCompute("/network/interfaces", settings["server"],
+            Controller.instance().getCompute("/network/interfaces", settings["compute_id"],
                                             self._getInterfacesFromServerCallback,
                                             progressText="Retrieving network interfaces...")

@@ -495,6 +531,17 @@ class CloudConfigurationPage(QtWidgets.QWidget, Ui_cloudConfigPageWidget):

        if not group:
            settings["name"] = self.uiNameLineEdit.text()
+            console_host = self.uiConsoleHostLineEdit.text().strip()
+
+            if self.uiConsoleTypeComboBox.currentText().lower() != "none":
+                if not console_host:
+                    QtWidgets.QMessageBox.critical(self, "Console host", "Console host cannot be blank if console type is not set to none")
+                    raise ConfigurationError()
+
+            settings["remote_console_host"] = console_host
+            settings["remote_console_port"] = self.uiConsolePortSpinBox.value()
+            settings["remote_console_type"] = self.uiConsoleTypeComboBox.currentText().lower()
+            settings["remote_console_http_path"] = self.uiConsoleHttpPathLineEdit.text().strip()

        if not node:
            # these are template settings
--- a/gns3/modules/builtin/pages/cloud_preferences_page.py
+++ b/gns3/modules/builtin/pages/cloud_preferences_page.py
@@ -21,13 +21,14 @@ Configuration page for cloud node preferences.

 import copy

-from gns3.qt import QtCore, QtGui, QtWidgets, qpartial
+from gns3.qt import QtCore, QtWidgets, qpartial
 from gns3.main_window import MainWindow
 from gns3.dialogs.configuration_dialog import ConfigurationDialog
 from gns3.compute_manager import ComputeManager
+from gns3.template_manager import TemplateManager
 from gns3.controller import Controller
+from gns3.template import Template

-from .. import Builtin
 from ..settings import CLOUD_SETTINGS
 from ..ui.cloud_preferences_page_ui import Ui_CloudPreferencesPageWidget
 from ..pages.cloud_configuration_page import CloudConfigurationPage
@@ -53,6 +54,11 @@ class CloudPreferencesPage(QtWidgets.QWidget, Ui_CloudPreferencesPageWidget):
        self.uiCloudNodesTreeWidget.itemSelectionChanged.connect(self._cloudNodeChangedSlot)

    def _createSectionItem(self, name):
+        """
+        Adds a new section to the tree widget.
+
+        :param name: section name
+        """

        section_item = QtWidgets.QTreeWidgetItem(self.uiCloudNodeInfoTreeWidget)
        section_item.setText(0, name)
@@ -62,15 +68,25 @@ class CloudPreferencesPage(QtWidgets.QWidget, Ui_CloudPreferencesPageWidget):
        return section_item

    def _refreshInfo(self, cloud_node):
+        """
+        Refreshes the content of the tree widget.
+        """

        self.uiCloudNodeInfoTreeWidget.clear()

        # fill out the General section
        section_item = self._createSectionItem("General")
        QtWidgets.QTreeWidgetItem(section_item, ["Template name:", cloud_node["name"]])
+        QtWidgets.QTreeWidgetItem(section_item, ["Template ID:", cloud_node.get("template_id", "none")])
+        if cloud_node["remote_console_type"] != "none":
+            QtWidgets.QTreeWidgetItem(section_item, ["Console host:", cloud_node["remote_console_host"]])
+            QtWidgets.QTreeWidgetItem(section_item, ["Console port:", "{}".format(cloud_node["remote_console_port"])])
+            if cloud_node["remote_console_type"] in ("http", "https"):
+                QtWidgets.QTreeWidgetItem(section_item, ["Console HTTP path:", cloud_node["remote_console_http_path"]])
+        QtWidgets.QTreeWidgetItem(section_item, ["Console type:", cloud_node["remote_console_type"]])
        QtWidgets.QTreeWidgetItem(section_item, ["Default name format:", cloud_node["default_name_format"]])
        try:
-            QtWidgets.QTreeWidgetItem(section_item, ["Server:", ComputeManager.instance().getCompute(cloud_node["server"]).name()])
+            QtWidgets.QTreeWidgetItem(section_item, ["Server:", ComputeManager.instance().getCompute(cloud_node["compute_id"]).name()])
        except KeyError:
            pass

@@ -81,7 +97,7 @@ class CloudPreferencesPage(QtWidgets.QWidget, Ui_CloudPreferencesPageWidget):

    def _cloudNodeChangedSlot(self):
        """
-        Loads a selected cloud node template from the tree widget.
+        Loads a selected cloud nodes from the tree widget.
        """

        selection = self.uiCloudNodesTreeWidget.selectedItems()
@@ -98,14 +114,14 @@ class CloudPreferencesPage(QtWidgets.QWidget, Ui_CloudPreferencesPageWidget):

    def _newCloudNodeSlot(self):
        """
-        Creates a new cloud node template.
+        Creates a new cloud node.
        """

        wizard = CloudWizard(self._cloud_nodes, parent=self)
        wizard.show()
        if wizard.exec_():
            new_cloud_settings = wizard.getSettings()
-            key = "{server}:{name}".format(server=new_cloud_settings["server"], name=new_cloud_settings["name"])
+            key = "{server}:{name}".format(server=new_cloud_settings["compute_id"], name=new_cloud_settings["name"])
            self._cloud_nodes[key] = CLOUD_SETTINGS.copy()
            self._cloud_nodes[key].update(new_cloud_settings)

@@ -119,7 +135,7 @@ class CloudPreferencesPage(QtWidgets.QWidget, Ui_CloudPreferencesPageWidget):

    def _editCloudNodeSlot(self):
        """
-        Edits a cloud node template.
+        Edits a cloud node.
        """

        item = self.uiCloudNodesTreeWidget.currentItem()
@@ -132,10 +148,10 @@ class CloudPreferencesPage(QtWidgets.QWidget, Ui_CloudPreferencesPageWidget):
                # update the icon
                Controller.instance().getSymbolIcon(cloud_node["symbol"], qpartial(self._setItemIcon, item))
                if cloud_node["name"] != item.text(0):
-                    new_key = "{server}:{name}".format(server=cloud_node["server"], name=cloud_node["name"])
+                    new_key = "{server}:{name}".format(server=cloud_node["compute_id"], name=cloud_node["name"])
                    if new_key in self._cloud_nodes:
                        QtWidgets.QMessageBox.critical(self, "Cloud node", "Cloud node name {} already exists for server {}".format(cloud_node["name"],
-                                                                                                                                    cloud_node["server"]))
+                                                                                                                                    cloud_node["compute_id"]))
                        cloud_node["name"] = item.text(0)
                        return
                    self._cloud_nodes[new_key] = self._cloud_nodes[key]
@@ -146,7 +162,7 @@ class CloudPreferencesPage(QtWidgets.QWidget, Ui_CloudPreferencesPageWidget):

    def _deleteCloudNodeSlot(self):
        """
-        Deletes a cloud node template.
+        Deletes a cloud node.
        """

        for item in self.uiCloudNodesTreeWidget.selectedItems():
@@ -160,10 +176,17 @@ class CloudPreferencesPage(QtWidgets.QWidget, Ui_CloudPreferencesPageWidget):
        Loads the cloud node preferences.
        """

-        builtin_module = Builtin.instance()
-        self._cloud_nodes = copy.deepcopy(builtin_module.cloudNodes())
-        self._items.clear()
+        self._cloud_nodes = {}
+        templates = TemplateManager.instance().templates()
+        for template_id, template in templates.items():
+            if template.template_type() == "cloud" and not template.builtin():
+                name = template.name()
+                server = template.compute_id()
+                #TODO: use template id for the key
+                key = "{server}:{name}".format(server=server, name=name)
+                self._cloud_nodes[key] = copy.deepcopy(template.settings())

+        self._items.clear()
        for key, cloud_node in self._cloud_nodes.items():
            item = QtWidgets.QTreeWidgetItem(self.uiCloudNodesTreeWidget)
            item.setText(0, cloud_node["name"])
@@ -177,6 +200,10 @@ class CloudPreferencesPage(QtWidgets.QWidget, Ui_CloudPreferencesPageWidget):
            self.uiCloudNodesTreeWidget.setMaximumWidth(self.uiCloudNodesTreeWidget.sizeHintForColumn(0) + 20)

    def _setItemIcon(self, item, icon):
+        """
+        Sets an item icon.
+        """
+
        item.setIcon(0, icon)
        self.uiCloudNodesTreeWidget.setMaximumWidth(self.uiCloudNodesTreeWidget.sizeHintForColumn(0) + 20)

@@ -185,4 +212,11 @@ class CloudPreferencesPage(QtWidgets.QWidget, Ui_CloudPreferencesPageWidget):
        Saves the cloud node preferences.
        """

-        Builtin.instance().setCloudNodes(self._cloud_nodes)
+        templates = []
+        for template in TemplateManager.instance().templates().values():
+            if template.template_type() != "cloud":
+                templates.append(template)
+        for template_settings in self._cloud_nodes.values():
+            templates.append(Template(template_settings))
+        TemplateManager.instance().updateList(templates)
+
--- a/gns3/modules/builtin/pages/ethernet_hub_configuration_page.py
+++ b/gns3/modules/builtin/pages/ethernet_hub_configuration_page.py
@@ -75,7 +75,6 @@ class EthernetHubConfigurationPage(QtWidgets.QWidget, Ui_ethernetHubConfigPageWi
        if not node:
            # these are template settings

-            # rename the label from "Name" to "Template name"
            self.uiNameLabel.setText("Template name:")

            # load the default name format
--- a/gns3/modules/builtin/pages/ethernet_hub_preferences_page.py
+++ b/gns3/modules/builtin/pages/ethernet_hub_preferences_page.py
@@ -21,14 +21,15 @@ Configuration page for Ethernet hub preferences.

 import copy

-from gns3.qt import QtCore, QtGui, QtWidgets, qpartial
+from gns3.qt import QtCore, QtWidgets, qpartial

 from gns3.main_window import MainWindow
 from gns3.dialogs.configuration_dialog import ConfigurationDialog
 from gns3.compute_manager import ComputeManager
+from gns3.template_manager import TemplateManager
 from gns3.controller import Controller
+from gns3.template import Template

-from .. import Builtin
 from ..settings import ETHERNET_HUB_SETTINGS
 from ..ui.ethernet_hub_preferences_page_ui import Ui_EthernetHubPreferencesPageWidget
 from ..pages.ethernet_hub_configuration_page import EthernetHubConfigurationPage
@@ -54,6 +55,11 @@ class EthernetHubPreferencesPage(QtWidgets.QWidget, Ui_EthernetHubPreferencesPag
        self.uiEthernetHubsTreeWidget.itemSelectionChanged.connect(self._ethernetHubChangedSlot)

    def _createSectionItem(self, name):
+        """
+        Adds a new section to the tree widget.
+
+        :param name: section name
+        """

        section_item = QtWidgets.QTreeWidgetItem(self.uiEthernetHubInfoTreeWidget)
        section_item.setText(0, name)
@@ -63,15 +69,19 @@ class EthernetHubPreferencesPage(QtWidgets.QWidget, Ui_EthernetHubPreferencesPag
        return section_item

    def _refreshInfo(self, ethernet_hub):
+        """
+        Refreshes the content of the tree widget.
+        """

        self.uiEthernetHubInfoTreeWidget.clear()

        # fill out the General section
        section_item = self._createSectionItem("General")
        QtWidgets.QTreeWidgetItem(section_item, ["Template name:", ethernet_hub["name"]])
+        QtWidgets.QTreeWidgetItem(section_item, ["Template ID:", ethernet_hub.get("template_id", "none")])
        QtWidgets.QTreeWidgetItem(section_item, ["Default name format:", ethernet_hub["default_name_format"]])
        try:
-            QtWidgets.QTreeWidgetItem(section_item, ["Server:", ComputeManager.instance().getCompute(ethernet_hub["server"]).name()])
+            QtWidgets.QTreeWidgetItem(section_item, ["Server:", ComputeManager.instance().getCompute(ethernet_hub["compute_id"]).name()])
        except KeyError:
            pass
        QtWidgets.QTreeWidgetItem(section_item, ["Number of ports:", str(len(ethernet_hub["ports_mapping"]))])
@@ -83,7 +93,7 @@ class EthernetHubPreferencesPage(QtWidgets.QWidget, Ui_EthernetHubPreferencesPag

    def _ethernetHubChangedSlot(self):
        """
-        Loads a selected Ethernet hub template from the tree widget.
+        Loads a selected Ethernet hub from the tree widget.
        """

        selection = self.uiEthernetHubsTreeWidget.selectedItems()
@@ -100,14 +110,14 @@ class EthernetHubPreferencesPage(QtWidgets.QWidget, Ui_EthernetHubPreferencesPag

    def _newEthernetHubSlot(self):
        """
-        Creates a new Ethernet hub template.
+        Creates a new Ethernet hub.
        """

        wizard = EthernetHubWizard(self._ethernet_hubs, parent=self)
        wizard.show()
        if wizard.exec_():
            new_ethernet_hub_settings = wizard.getSettings()
-            key = "{server}:{name}".format(server=new_ethernet_hub_settings["server"], name=new_ethernet_hub_settings["name"])
+            key = "{server}:{name}".format(server=new_ethernet_hub_settings["compute_id"], name=new_ethernet_hub_settings["name"])
            self._ethernet_hubs[key] = ETHERNET_HUB_SETTINGS.copy()
            self._ethernet_hubs[key].update(new_ethernet_hub_settings)

@@ -120,7 +130,7 @@ class EthernetHubPreferencesPage(QtWidgets.QWidget, Ui_EthernetHubPreferencesPag

    def _editEthernetHubSlot(self):
        """
-        Edits an Ethernet hub template.
+        Edits an Ethernet hub.
        """

        item = self.uiEthernetHubsTreeWidget.currentItem()
@@ -133,10 +143,10 @@ class EthernetHubPreferencesPage(QtWidgets.QWidget, Ui_EthernetHubPreferencesPag
                # update the icon
                Controller.instance().getSymbolIcon(ethernet_hub["symbol"], qpartial(self._setItemIcon, item))
                if ethernet_hub["name"] != item.text(0):
-                    new_key = "{server}:{name}".format(server=ethernet_hub["server"], name=ethernet_hub["name"])
+                    new_key = "{server}:{name}".format(server=ethernet_hub["compute_id"], name=ethernet_hub["name"])
                    if new_key in self._ethernet_hubs:
                        QtWidgets.QMessageBox.critical(self, "Ethernet hub", "Ethernet hub name {} already exists for server {}".format(ethernet_hub["name"],
-                                                                                                                                        ethernet_hub["server"]))
+                                                                                                                                        ethernet_hub["compute_id"]))
                        ethernet_hub["name"] = item.text(0)
                        return
                    self._ethernet_hubs[new_key] = self._ethernet_hubs[key]
@@ -147,7 +157,7 @@ class EthernetHubPreferencesPage(QtWidgets.QWidget, Ui_EthernetHubPreferencesPag

    def _deleteEthernetHubSlot(self):
        """
-        Deletes an Ethernet hub template.
+        Deletes an Ethernet hub.
        """

        for item in self.uiEthernetHubsTreeWidget.selectedItems():
@@ -161,10 +171,17 @@ class EthernetHubPreferencesPage(QtWidgets.QWidget, Ui_EthernetHubPreferencesPag
        Loads the ethernet hub preferences.
        """

-        builtin_module = Builtin.instance()
-        self._ethernet_hubs = copy.deepcopy(builtin_module.ethernetHubs())
-        self._items.clear()
+        self._ethernet_hubs = {}
+        templates = TemplateManager.instance().templates()
+        for template_id, template in templates.items():
+            if template.template_type() == "ethernet_hub" and not template.builtin():
+                name = template.name()
+                server = template.compute_id()
+                #TODO: use template id for the key
+                key = "{server}:{name}".format(server=server, name=name)
+                self._ethernet_hubs[key] = copy.deepcopy(template.settings())

+        self._items.clear()
        for key, ethernet_hub in self._ethernet_hubs.items():
            item = QtWidgets.QTreeWidgetItem(self.uiEthernetHubsTreeWidget)
            item.setText(0, ethernet_hub["name"])
@@ -178,6 +195,10 @@ class EthernetHubPreferencesPage(QtWidgets.QWidget, Ui_EthernetHubPreferencesPag
            self.uiEthernetHubsTreeWidget.setMaximumWidth(self.uiEthernetHubsTreeWidget.sizeHintForColumn(0) + 20)

    def _setItemIcon(self, item, icon):
+        """
+        Sets an item icon.
+        """
+
        item.setIcon(0, icon)
        self.uiEthernetHubsTreeWidget.setMaximumWidth(self.uiEthernetHubsTreeWidget.sizeHintForColumn(0) + 20)

@@ -186,4 +207,11 @@ class EthernetHubPreferencesPage(QtWidgets.QWidget, Ui_EthernetHubPreferencesPag
        Saves the Ethernet hub preferences.
        """

-        Builtin.instance().setEthernetHubs(self._ethernet_hubs)
+        templates = []
+        for template in TemplateManager.instance().templates().values():
+            if template.template_type() != "ethernet_hub":
+                templates.append(template)
+        for template_settings in self._ethernet_hubs.values():
+            templates.append(Template(template_settings))
+        TemplateManager.instance().updateList(templates)
+
--- a/gns3/modules/builtin/pages/ethernet_switch_configuration_page.py
+++ b/gns3/modules/builtin/pages/ethernet_switch_configuration_page.py
@@ -196,7 +196,6 @@ class EthernetSwitchConfigurationPage(QtWidgets.QWidget, Ui_ethernetSwitchConfig
        if not node:
            # these are template settings

-            # rename the label from "Name" to "Template name"
            self.uiNameLabel.setText("Template name:")

            # load the default name format
@@ -223,12 +222,17 @@ class EthernetSwitchConfigurationPage(QtWidgets.QWidget, Ui_ethernetSwitchConfig
        for port_info in settings["ports_mapping"]:
            item = TreeWidgetItem(self.uiPortsTreeWidget)
            item.setText(0, str(port_info["port_number"]))
-            item.setText(1, str(port_info["vlan"]))
-            item.setText(2, port_info["type"])
+            item.setText(1, str(port_info.get("vlan", 1)))
+            item.setText(2, port_info.get("type", "access"))
            item.setText(3, port_info.get("ethertype", ""))
            self.uiPortsTreeWidget.addTopLevelItem(item)
            self._ports[port_info["port_number"]] = port_info

+        # load the console type
+        index = self.uiConsoleTypeComboBox.findText(settings["console_type"])
+        if index != -1:
+            self.uiConsoleTypeComboBox.setCurrentIndex(index)
+
        self.uiPortsTreeWidget.resizeColumnToContents(0)
        self.uiPortsTreeWidget.resizeColumnToContents(1)
        if len(self._ports) > 0:
@@ -266,5 +270,8 @@ class EthernetSwitchConfigurationPage(QtWidgets.QWidget, Ui_ethernetSwitchConfig

            settings["category"] = self.uiCategoryComboBox.itemData(self.uiCategoryComboBox.currentIndex())

+        # save console type
+        settings["console_type"] = self.uiConsoleTypeComboBox.currentText().lower()
+
        settings["ports_mapping"] = list(self._ports.values())
        return settings
--- a/gns3/modules/builtin/pages/ethernet_switch_preferences_page.py
+++ b/gns3/modules/builtin/pages/ethernet_switch_preferences_page.py
@@ -21,14 +21,15 @@ Configuration page for Ethernet switch preferences.

 import copy

-from gns3.qt import QtCore, QtGui, QtWidgets, qpartial
+from gns3.qt import QtCore, QtWidgets, qpartial
 from gns3.controller import Controller

 from gns3.main_window import MainWindow
 from gns3.dialogs.configuration_dialog import ConfigurationDialog
 from gns3.compute_manager import ComputeManager
+from gns3.template_manager import TemplateManager
+from gns3.template import Template

-from .. import Builtin
 from ..settings import ETHERNET_SWITCH_SETTINGS
 from ..ui.ethernet_switch_preferences_page_ui import Ui_EthernetSwitchPreferencesPageWidget
 from ..pages.ethernet_switch_configuration_page import EthernetSwitchConfigurationPage
@@ -54,6 +55,11 @@ class EthernetSwitchPreferencesPage(QtWidgets.QWidget, Ui_EthernetSwitchPreferen
        self.uiEthernetSwitchesTreeWidget.itemSelectionChanged.connect(self._ethernetSwitchChangedSlot)

    def _createSectionItem(self, name):
+        """
+        Adds a new section to the tree widget.
+
+        :param name: section name
+        """

        section_item = QtWidgets.QTreeWidgetItem(self.uiEthernetSwitchInfoTreeWidget)
        section_item.setText(0, name)
@@ -63,18 +69,23 @@ class EthernetSwitchPreferencesPage(QtWidgets.QWidget, Ui_EthernetSwitchPreferen
        return section_item

    def _refreshInfo(self, ethernet_switch):
+        """
+        Refreshes the content of the tree widget.
+        """

        self.uiEthernetSwitchInfoTreeWidget.clear()

        # fill out the General section
        section_item = self._createSectionItem("General")
        QtWidgets.QTreeWidgetItem(section_item, ["Template name:", ethernet_switch["name"]])
+        QtWidgets.QTreeWidgetItem(section_item, ["Template ID:", ethernet_switch.get("template_id", "none")])
        QtWidgets.QTreeWidgetItem(section_item, ["Default name format:", ethernet_switch["default_name_format"]])
        try:
-            QtWidgets.QTreeWidgetItem(section_item, ["Server:", ComputeManager.instance().getCompute(ethernet_switch["server"]).name()])
+            QtWidgets.QTreeWidgetItem(section_item, ["Server:", ComputeManager.instance().getCompute(ethernet_switch["compute_id"]).name()])
        except KeyError:
            pass

+        QtWidgets.QTreeWidgetItem(section_item, ["Console type:", ethernet_switch["console_type"]])
        for port in ethernet_switch["ports_mapping"]:
            section_item = self._createSectionItem("Port{}".format(port["port_number"]))
            QtWidgets.QTreeWidgetItem(section_item, ["Name:", port["name"]])
@@ -88,7 +99,7 @@ class EthernetSwitchPreferencesPage(QtWidgets.QWidget, Ui_EthernetSwitchPreferen

    def _ethernetSwitchChangedSlot(self):
        """
-        Loads a selected Ethernet switch template from the tree widget.
+        Loads a selected Ethernet switch from the tree widget.
        """

        selection = self.uiEthernetSwitchesTreeWidget.selectedItems()
@@ -105,14 +116,14 @@ class EthernetSwitchPreferencesPage(QtWidgets.QWidget, Ui_EthernetSwitchPreferen

    def _newEthernetSwitchSlot(self):
        """
-        Creates a new Ethernet switch template.
+        Creates a new Ethernet switch.
        """

        wizard = EthernetSwitchWizard(self._ethernet_switches, parent=self)
        wizard.show()
        if wizard.exec_():
            new_ethernet_switch_settings = wizard.getSettings()
-            key = "{server}:{name}".format(server=new_ethernet_switch_settings["server"], name=new_ethernet_switch_settings["name"])
+            key = "{server}:{name}".format(server=new_ethernet_switch_settings["compute_id"], name=new_ethernet_switch_settings["name"])
            self._ethernet_switches[key] = ETHERNET_SWITCH_SETTINGS.copy()
            self._ethernet_switches[key].update(new_ethernet_switch_settings)

@@ -126,7 +137,7 @@ class EthernetSwitchPreferencesPage(QtWidgets.QWidget, Ui_EthernetSwitchPreferen

    def _editEthernetSwitchSlot(self):
        """
-        Edits an Ethernet switch template.
+        Edits an Ethernet switch.
        """

        item = self.uiEthernetSwitchesTreeWidget.currentItem()
@@ -139,10 +150,10 @@ class EthernetSwitchPreferencesPage(QtWidgets.QWidget, Ui_EthernetSwitchPreferen
                # update the icon
                Controller.instance().getSymbolIcon(ethernet_switch["symbol"], qpartial(self._setItemIcon, item))
                if ethernet_switch["name"] != item.text(0):
-                    new_key = "{server}:{name}".format(server=ethernet_switch["server"], name=ethernet_switch["name"])
+                    new_key = "{server}:{name}".format(server=ethernet_switch["compute_id"], name=ethernet_switch["name"])
                    if new_key in self._ethernet_switches:
                        QtWidgets.QMessageBox.critical(self, "Ethernet switch", "Ethernet switch name {} already exists for server {}".format(ethernet_switch["name"],
-                                                                                                                                              ethernet_switch["server"]))
+                                                                                                                                              ethernet_switch["compute_id"]))
                        ethernet_switch["name"] = item.text(0)
                        return
                    self._ethernet_switches[new_key] = self._ethernet_switches[key]
@@ -153,7 +164,7 @@ class EthernetSwitchPreferencesPage(QtWidgets.QWidget, Ui_EthernetSwitchPreferen

    def _deleteEthernetSwitchSlot(self):
        """
-        Deletes an Ethernet switch template.
+        Deletes an Ethernet switch.
        """
        for item in self.uiEthernetSwitchesTreeWidget.selectedItems():
            if item:
@@ -166,10 +177,17 @@ class EthernetSwitchPreferencesPage(QtWidgets.QWidget, Ui_EthernetSwitchPreferen
        Loads the ethernet switch preferences.
        """

-        builtin_module = Builtin.instance()
-        self._ethernet_switches = copy.deepcopy(builtin_module.ethernetSwitches())
-        self._items.clear()
+        self._ethernet_switches = {}
+        templates = TemplateManager.instance().templates()
+        for template_id, template in templates.items():
+            if template.template_type() == "ethernet_switch" and not template.builtin():
+                name = template.name()
+                server = template.compute_id()
+                #TODO: use template id for the key
+                key = "{server}:{name}".format(server=server, name=name)
+                self._ethernet_switches[key] = copy.deepcopy(template.settings())

+        self._items.clear()
        for key, ethernet_switch in self._ethernet_switches.items():
            item = QtWidgets.QTreeWidgetItem(self.uiEthernetSwitchesTreeWidget)
            item.setText(0, ethernet_switch["name"])
@@ -182,13 +200,24 @@ class EthernetSwitchPreferencesPage(QtWidgets.QWidget, Ui_EthernetSwitchPreferen
            self.uiEthernetSwitchesTreeWidget.sortByColumn(0, QtCore.Qt.AscendingOrder)
            self.uiEthernetSwitchesTreeWidget.setMaximumWidth(self.uiEthernetSwitchesTreeWidget.sizeHintForColumn(0) + 20)

+    def _setItemIcon(self, item, icon):
+        """
+        Sets an item icon.
+        """
+
+        item.setIcon(0, icon)
+        self.uiEthernetSwitchesTreeWidget.setMaximumWidth(self.uiEthernetSwitchesTreeWidget.sizeHintForColumn(0) + 20)
+
    def savePreferences(self):
        """
        Saves the Ethernet switch preferences.
        """

-        Builtin.instance().setEthernetSwitches(self._ethernet_switches)
+        templates = []
+        for template in TemplateManager.instance().templates().values():
+            if template.template_type() != "ethernet_switch":
+                templates.append(template)
+        for template_settings in self._ethernet_switches.values():
+            templates.append(Template(template_settings))
+        TemplateManager.instance().updateList(templates)

-    def _setItemIcon(self, item, icon):
-        item.setIcon(0, icon)
-        self.uiEthernetSwitchesTreeWidget.setMaximumWidth(self.uiEthernetSwitchesTreeWidget.sizeHintForColumn(0) + 20)
--- a/gns3/modules/builtin/settings.py
+++ b/gns3/modules/builtin/settings.py
@@ -19,18 +19,30 @@
 Default Built-in settings.
 """

+import sys
+
 from gns3.node import Node

-BUILTIN_SETTINGS = {
-}
+if sys.platform.startswith("linux"):
+    DEFAULT_NAT_INTERFACE = "virbr0"
+else:
+    DEFAULT_NAT_INTERFACE = "vmnet8"

+BUILTIN_SETTINGS = {
+    "default_nat_interface": DEFAULT_NAT_INTERFACE
+}

 CLOUD_SETTINGS = {
    "name": "",
+    "remote_console_host": "127.0.0.1",
+    "remote_console_port": 23,
+    "remote_console_type": "none",
+    "remote_console_http_path": "/",
    "default_name_format": "Cloud{0}",
    "symbol": ":/symbols/cloud.svg",
    "category": Node.end_devices,
    "ports_mapping": [],
+    "node_type": "cloud"
 }

 ETHERNET_HUB_SETTINGS = {
@@ -39,6 +51,7 @@ ETHERNET_HUB_SETTINGS = {
    "symbol": ":/symbols/hub.svg",
    "category": Node.switches,
    "ports_mapping": [],
+    "node_type": "ethernet_hub"
 }

 ETHERNET_SWITCH_SETTINGS = {
@@ -46,5 +59,7 @@ ETHERNET_SWITCH_SETTINGS = {
    "default_name_format": "Switch{0}",
    "symbol": ":/symbols/ethernet_switch.svg",
    "category": Node.switches,
+    "console_type": "none",
    "ports_mapping": [],
+    "node_type": "ethernet_switch"
 }
--- a/gns3/modules/builtin/ui/builtin_preferences_page.ui
+++ b/gns3/modules/builtin/ui/builtin_preferences_page.ui
@@ -6,8 +6,8 @@
   <rect>
    <x>0</x>
    <y>0</y>
-    <width>330</width>
-    <height>200</height>
+    <width>456</width>
+    <height>385</height>
   </rect>
  </property>
  <property name="windowTitle">
@@ -26,8 +26,18 @@
      <attribute name="title">
       <string>Local settings</string>
      </attribute>
-      <layout class="QVBoxLayout" name="verticalLayout_2">
-       <item>
+      <layout class="QGridLayout" name="gridLayout">
+       <item row="0" column="0">
+        <widget class="QLabel" name="label">
+         <property name="text">
+          <string>Default NAT interface:</string>
+         </property>
+        </widget>
+       </item>
+       <item row="1" column="0">
+        <widget class="QComboBox" name="uiNATInterfaceComboBox"/>
+       </item>
+       <item row="2" column="0">
        <spacer name="verticalSpacer">
         <property name="orientation">
          <enum>Qt::Vertical</enum>
--- a/gns3/modules/builtin/ui/builtin_preferences_page_ui.py
+++ b/gns3/modules/builtin/ui/builtin_preferences_page_ui.py
@@ -2,8 +2,7 @@

 # Form implementation generated from reading ui file '/home/grossmj/PycharmProjects/gns3-gui/gns3/modules/builtin/ui/builtin_preferences_page.ui'
 #
-# Created: Wed Dec  7 21:40:18 2016
-#      by: PyQt5 UI code generator 5.2.1
+# Created by: PyQt5 UI code generator 5.9.1
 #
 # WARNING! All changes made in this file will be lost!

@@ -12,7 +11,7 @@ from PyQt5 import QtCore, QtGui, QtWidgets
 class Ui_BuiltinPreferencesPageWidget(object):
    def setupUi(self, BuiltinPreferencesPageWidget):
        BuiltinPreferencesPageWidget.setObjectName("BuiltinPreferencesPageWidget")
-        BuiltinPreferencesPageWidget.resize(330, 200)
+        BuiltinPreferencesPageWidget.resize(456, 385)
        self.verticalLayout = QtWidgets.QVBoxLayout(BuiltinPreferencesPageWidget)
        self.verticalLayout.setObjectName("verticalLayout")
        self.uiTabWidget = QtWidgets.QTabWidget(BuiltinPreferencesPageWidget)
@@ -20,10 +19,16 @@ class Ui_BuiltinPreferencesPageWidget(object):
        self.uiTabWidget.setObjectName("uiTabWidget")
        self.uiServerSettingsTabWidget = QtWidgets.QWidget()
        self.uiServerSettingsTabWidget.setObjectName("uiServerSettingsTabWidget")
-        self.verticalLayout_2 = QtWidgets.QVBoxLayout(self.uiServerSettingsTabWidget)
-        self.verticalLayout_2.setObjectName("verticalLayout_2")
+        self.gridLayout = QtWidgets.QGridLayout(self.uiServerSettingsTabWidget)
+        self.gridLayout.setObjectName("gridLayout")
+        self.label = QtWidgets.QLabel(self.uiServerSettingsTabWidget)
+        self.label.setObjectName("label")
+        self.gridLayout.addWidget(self.label, 0, 0, 1, 1)
+        self.uiNATInterfaceComboBox = QtWidgets.QComboBox(self.uiServerSettingsTabWidget)
+        self.uiNATInterfaceComboBox.setObjectName("uiNATInterfaceComboBox")
+        self.gridLayout.addWidget(self.uiNATInterfaceComboBox, 1, 0, 1, 1)
        spacerItem = QtWidgets.QSpacerItem(20, 5, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
-        self.verticalLayout_2.addItem(spacerItem)
+        self.gridLayout.addItem(spacerItem, 2, 0, 1, 1)
        self.uiTabWidget.addTab(self.uiServerSettingsTabWidget, "")
        self.verticalLayout.addWidget(self.uiTabWidget)
        self.horizontalLayout_2 = QtWidgets.QHBoxLayout()
@@ -42,6 +47,7 @@ class Ui_BuiltinPreferencesPageWidget(object):
    def retranslateUi(self, BuiltinPreferencesPageWidget):
        _translate = QtCore.QCoreApplication.translate
        BuiltinPreferencesPageWidget.setWindowTitle(_translate("BuiltinPreferencesPageWidget", "Built-in"))
+        self.label.setText(_translate("BuiltinPreferencesPageWidget", "Default NAT interface:"))
        self.uiTabWidget.setTabText(self.uiTabWidget.indexOf(self.uiServerSettingsTabWidget), _translate("BuiltinPreferencesPageWidget", "Local settings"))
        self.uiRestoreDefaultsPushButton.setText(_translate("BuiltinPreferencesPageWidget", "Restore defaults"))

--- a/gns3/modules/builtin/ui/cloud_configuration_page.ui
+++ b/gns3/modules/builtin/ui/cloud_configuration_page.ui
@@ -6,12 +6,12 @@
   <rect>
    <x>0</x>
    <y>0</y>
-    <width>1000</width>
-    <height>378</height>
+    <width>979</width>
+    <height>564</height>
   </rect>
  </property>
  <property name="windowTitle">
-   <string>Cloud configuration</string>
+   <string>Cloud template configuration</string>
  </property>
  <property name="whatsThis">
   <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;A cloud node allows you to connect your project to the &amp;quot;real world&amp;quot; (a network or host) using either an Ethernet interface, a TAP interface (Linux only) or even an UDP tunnel. &lt;span style=&quot; font-weight:600;&quot;&gt;Please be aware that Wifi interfaces may not work properly.&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
@@ -390,6 +390,19 @@
       <string>Misc.</string>
      </attribute>
      <layout class="QGridLayout" name="gridLayout">
+       <item row="3" column="2">
+        <widget class="QSpinBox" name="uiConsolePortSpinBox">
+         <property name="minimum">
+          <number>1</number>
+         </property>
+         <property name="maximum">
+          <number>65535</number>
+         </property>
+         <property name="value">
+          <number>23</number>
+         </property>
+        </widget>
+       </item>
       <item row="0" column="0">
        <widget class="QLabel" name="uiNameLabel">
         <property name="text">
@@ -400,24 +413,64 @@
       <item row="0" column="2">
        <widget class="QLineEdit" name="uiNameLineEdit"/>
       </item>
-       <item row="1" column="0" colspan="2">
+       <item row="2" column="0">
+        <widget class="QLabel" name="uiConsoleHostLabel">
+         <property name="text">
+          <string>Console host:</string>
+         </property>
+        </widget>
+       </item>
+       <item row="2" column="2">
+        <widget class="QLineEdit" name="uiConsoleHostLineEdit"/>
+       </item>
+       <item row="3" column="0">
+        <widget class="QLabel" name="labeluiConsolePortLabel">
+         <property name="text">
+          <string>Console port:</string>
+         </property>
+        </widget>
+       </item>
+       <item row="5" column="0">
+        <widget class="QLabel" name="uiConsoleHttpPathLabel">
+         <property name="text">
+          <string>Console HTTP path:</string>
+         </property>
+        </widget>
+       </item>
+       <item row="5" column="2">
+        <widget class="QLineEdit" name="uiConsoleHttpPathLineEdit"/>
+       </item>
+       <item row="6" column="0">
        <widget class="QLabel" name="uiDefaultNameFormatLabel">
         <property name="text">
          <string>Default name format:</string>
         </property>
        </widget>
       </item>
-       <item row="1" column="2">
+       <item row="6" column="2">
        <widget class="QLineEdit" name="uiDefaultNameFormatLineEdit"/>
       </item>
-       <item row="2" column="0" colspan="2">
+       <item row="7" column="0">
        <widget class="QLabel" name="uiSymbolLabel">
         <property name="text">
          <string>Symbol:</string>
         </property>
        </widget>
       </item>
-       <item row="2" column="2">
+       <item row="9" column="0" colspan="3">
+        <spacer name="verticalSpacer">
+         <property name="orientation">
+          <enum>Qt::Vertical</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>20</width>
+           <height>399</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item row="7" column="2">
        <layout class="QHBoxLayout" name="horizontalLayout_7">
         <item>
          <widget class="QLineEdit" name="uiSymbolLineEdit"/>
@@ -434,30 +487,73 @@
         </item>
        </layout>
       </item>
-       <item row="3" column="0" colspan="2">
+       <item row="8" column="0">
        <widget class="QLabel" name="uiCategoryLabel">
         <property name="text">
          <string>Category:</string>
         </property>
        </widget>
       </item>
-       <item row="3" column="2">
+       <item row="8" column="2">
        <widget class="QComboBox" name="uiCategoryComboBox"/>
       </item>
-       <item row="4" column="1" colspan="2">
-        <spacer name="verticalSpacer">
-         <property name="orientation">
-          <enum>Qt::Vertical</enum>
+       <item row="1" column="0">
+        <widget class="QLabel" name="uiConsoleTypeLabel">
+         <property name="text">
+          <string>Console type:</string>
         </property>
-         <property name="sizeHint" stdset="0">
-          <size>
-           <width>20</width>
-           <height>399</height>
-          </size>
-         </property>
-        </spacer>
+        </widget>
+       </item>
+       <item row="1" column="2">
+        <widget class="QComboBox" name="uiConsoleTypeComboBox">
+         <item>
+          <property name="text">
+           <string>telnet</string>
+          </property>
+         </item>
+         <item>
+          <property name="text">
+           <string>vnc</string>
+          </property>
+         </item>
+         <item>
+          <property name="text">
+           <string>spice</string>
+          </property>
+         </item>
+         <item>
+          <property name="text">
+           <string>http</string>
+          </property>
+         </item>
+         <item>
+          <property name="text">
+           <string>https</string>
+          </property>
+         </item>
+         <item>
+          <property name="text">
+           <string>none</string>
+          </property>
+         </item>
+        </widget>
       </item>
      </layout>
+      <zorder>uiNameLabel</zorder>
+      <zorder>uiNameLineEdit</zorder>
+      <zorder>uiDefaultNameFormatLabel</zorder>
+      <zorder>uiDefaultNameFormatLineEdit</zorder>
+      <zorder>uiSymbolLabel</zorder>
+      <zorder>uiCategoryLabel</zorder>
+      <zorder>uiCategoryComboBox</zorder>
+      <zorder>labeluiConsolePortLabel</zorder>
+      <zorder>uiConsoleHostLabel</zorder>
+      <zorder>uiConsoleHostLineEdit</zorder>
+      <zorder>uiConsolePortSpinBox</zorder>
+      <zorder>uiConsoleHttpPathLabel</zorder>
+      <zorder>uiConsoleHttpPathLineEdit</zorder>
+      <zorder>uiConsoleTypeLabel</zorder>
+      <zorder>uiConsoleTypeComboBox</zorder>
     </widget>
    </widget>
   </item>
--- a/gns3/modules/builtin/ui/cloud_configuration_page_ui.py
+++ b/gns3/modules/builtin/ui/cloud_configuration_page_ui.py
@@ -2,7 +2,7 @@

 # Form implementation generated from reading ui file '/home/grossmj/PycharmProjects/gns3-gui/gns3/modules/builtin/ui/cloud_configuration_page.ui'
 #
-# Created by: PyQt5 UI code generator 5.5.1
+# Created by: PyQt5 UI code generator 5.11.3
 #
 # WARNING! All changes made in this file will be lost!

@@ -11,7 +11,7 @@ from PyQt5 import QtCore, QtGui, QtWidgets
 class Ui_cloudConfigPageWidget(object):
    def setupUi(self, cloudConfigPageWidget):
        cloudConfigPageWidget.setObjectName("cloudConfigPageWidget")
-        cloudConfigPageWidget.resize(1000, 378)
+        cloudConfigPageWidget.resize(979, 564)
        self.verticalLayout = QtWidgets.QVBoxLayout(cloudConfigPageWidget)
        self.verticalLayout.setObjectName("verticalLayout")
        self.uiTabWidget = QtWidgets.QTabWidget(cloudConfigPageWidget)
@@ -199,21 +199,44 @@ class Ui_cloudConfigPageWidget(object):
        self.MiscTab.setObjectName("MiscTab")
        self.gridLayout = QtWidgets.QGridLayout(self.MiscTab)
        self.gridLayout.setObjectName("gridLayout")
+        self.uiConsolePortSpinBox = QtWidgets.QSpinBox(self.MiscTab)
+        self.uiConsolePortSpinBox.setMinimum(1)
+        self.uiConsolePortSpinBox.setMaximum(65535)
+        self.uiConsolePortSpinBox.setProperty("value", 23)
+        self.uiConsolePortSpinBox.setObjectName("uiConsolePortSpinBox")
+        self.gridLayout.addWidget(self.uiConsolePortSpinBox, 3, 2, 1, 1)
        self.uiNameLabel = QtWidgets.QLabel(self.MiscTab)
        self.uiNameLabel.setObjectName("uiNameLabel")
        self.gridLayout.addWidget(self.uiNameLabel, 0, 0, 1, 1)
        self.uiNameLineEdit = QtWidgets.QLineEdit(self.MiscTab)
        self.uiNameLineEdit.setObjectName("uiNameLineEdit")
        self.gridLayout.addWidget(self.uiNameLineEdit, 0, 2, 1, 1)
+        self.uiConsoleHostLabel = QtWidgets.QLabel(self.MiscTab)
+        self.uiConsoleHostLabel.setObjectName("uiConsoleHostLabel")
+        self.gridLayout.addWidget(self.uiConsoleHostLabel, 2, 0, 1, 1)
+        self.uiConsoleHostLineEdit = QtWidgets.QLineEdit(self.MiscTab)
+        self.uiConsoleHostLineEdit.setObjectName("uiConsoleHostLineEdit")
+        self.gridLayout.addWidget(self.uiConsoleHostLineEdit, 2, 2, 1, 1)
+        self.labeluiConsolePortLabel = QtWidgets.QLabel(self.MiscTab)
+        self.labeluiConsolePortLabel.setObjectName("labeluiConsolePortLabel")
+        self.gridLayout.addWidget(self.labeluiConsolePortLabel, 3, 0, 1, 1)
+        self.uiConsoleHttpPathLabel = QtWidgets.QLabel(self.MiscTab)
+        self.uiConsoleHttpPathLabel.setObjectName("uiConsoleHttpPathLabel")
+        self.gridLayout.addWidget(self.uiConsoleHttpPathLabel, 5, 0, 1, 1)
+        self.uiConsoleHttpPathLineEdit = QtWidgets.QLineEdit(self.MiscTab)
+        self.uiConsoleHttpPathLineEdit.setObjectName("uiConsoleHttpPathLineEdit")
+        self.gridLayout.addWidget(self.uiConsoleHttpPathLineEdit, 5, 2, 1, 1)
        self.uiDefaultNameFormatLabel = QtWidgets.QLabel(self.MiscTab)
        self.uiDefaultNameFormatLabel.setObjectName("uiDefaultNameFormatLabel")
-        self.gridLayout.addWidget(self.uiDefaultNameFormatLabel, 1, 0, 1, 2)
+        self.gridLayout.addWidget(self.uiDefaultNameFormatLabel, 6, 0, 1, 1)
        self.uiDefaultNameFormatLineEdit = QtWidgets.QLineEdit(self.MiscTab)
        self.uiDefaultNameFormatLineEdit.setObjectName("uiDefaultNameFormatLineEdit")
-        self.gridLayout.addWidget(self.uiDefaultNameFormatLineEdit, 1, 2, 1, 1)
+        self.gridLayout.addWidget(self.uiDefaultNameFormatLineEdit, 6, 2, 1, 1)
        self.uiSymbolLabel = QtWidgets.QLabel(self.MiscTab)
        self.uiSymbolLabel.setObjectName("uiSymbolLabel")
-        self.gridLayout.addWidget(self.uiSymbolLabel, 2, 0, 1, 2)
+        self.gridLayout.addWidget(self.uiSymbolLabel, 7, 0, 1, 1)
+        spacerItem2 = QtWidgets.QSpacerItem(20, 399, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
+        self.gridLayout.addItem(spacerItem2, 9, 0, 1, 3)
        self.horizontalLayout_7 = QtWidgets.QHBoxLayout()
        self.horizontalLayout_7.setObjectName("horizontalLayout_7")
        self.uiSymbolLineEdit = QtWidgets.QLineEdit(self.MiscTab)
@@ -223,15 +246,40 @@ class Ui_cloudConfigPageWidget(object):
        self.uiSymbolToolButton.setToolButtonStyle(QtCore.Qt.ToolButtonTextOnly)
        self.uiSymbolToolButton.setObjectName("uiSymbolToolButton")
        self.horizontalLayout_7.addWidget(self.uiSymbolToolButton)
-        self.gridLayout.addLayout(self.horizontalLayout_7, 2, 2, 1, 1)
+        self.gridLayout.addLayout(self.horizontalLayout_7, 7, 2, 1, 1)
        self.uiCategoryLabel = QtWidgets.QLabel(self.MiscTab)
        self.uiCategoryLabel.setObjectName("uiCategoryLabel")
-        self.gridLayout.addWidget(self.uiCategoryLabel, 3, 0, 1, 2)
+        self.gridLayout.addWidget(self.uiCategoryLabel, 8, 0, 1, 1)
        self.uiCategoryComboBox = QtWidgets.QComboBox(self.MiscTab)
        self.uiCategoryComboBox.setObjectName("uiCategoryComboBox")
-        self.gridLayout.addWidget(self.uiCategoryComboBox, 3, 2, 1, 1)
-        spacerItem2 = QtWidgets.QSpacerItem(20, 399, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
-        self.gridLayout.addItem(spacerItem2, 4, 1, 1, 2)
+        self.gridLayout.addWidget(self.uiCategoryComboBox, 8, 2, 1, 1)
+        self.uiConsoleTypeLabel = QtWidgets.QLabel(self.MiscTab)
+        self.uiConsoleTypeLabel.setObjectName("uiConsoleTypeLabel")
+        self.gridLayout.addWidget(self.uiConsoleTypeLabel, 1, 0, 1, 1)
+        self.uiConsoleTypeComboBox = QtWidgets.QComboBox(self.MiscTab)
+        self.uiConsoleTypeComboBox.setObjectName("uiConsoleTypeComboBox")
+        self.uiConsoleTypeComboBox.addItem("")
+        self.uiConsoleTypeComboBox.addItem("")
+        self.uiConsoleTypeComboBox.addItem("")
+        self.uiConsoleTypeComboBox.addItem("")
+        self.uiConsoleTypeComboBox.addItem("")
+        self.uiConsoleTypeComboBox.addItem("")
+        self.gridLayout.addWidget(self.uiConsoleTypeComboBox, 1, 2, 1, 1)
+        self.uiNameLabel.raise_()
+        self.uiNameLineEdit.raise_()
+        self.uiDefaultNameFormatLabel.raise_()
+        self.uiDefaultNameFormatLineEdit.raise_()
+        self.uiSymbolLabel.raise_()
+        self.uiCategoryLabel.raise_()
+        self.uiCategoryComboBox.raise_()
+        self.labeluiConsolePortLabel.raise_()
+        self.uiConsoleHostLabel.raise_()
+        self.uiConsoleHostLineEdit.raise_()
+        self.uiConsolePortSpinBox.raise_()
+        self.uiConsoleHttpPathLabel.raise_()
+        self.uiConsoleHttpPathLineEdit.raise_()
+        self.uiConsoleTypeLabel.raise_()
+        self.uiConsoleTypeComboBox.raise_()
        self.uiTabWidget.addTab(self.MiscTab, "")
        self.verticalLayout.addWidget(self.uiTabWidget)

@@ -241,7 +289,7 @@ class Ui_cloudConfigPageWidget(object):

    def retranslateUi(self, cloudConfigPageWidget):
        _translate = QtCore.QCoreApplication.translate
-        cloudConfigPageWidget.setWindowTitle(_translate("cloudConfigPageWidget", "Cloud configuration"))
+        cloudConfigPageWidget.setWindowTitle(_translate("cloudConfigPageWidget", "Cloud template configuration"))
        cloudConfigPageWidget.setWhatsThis(_translate("cloudConfigPageWidget", "<html><head/><body><p>A cloud node allows you to connect your project to the &quot;real world&quot; (a network or host) using either an Ethernet interface, a TAP interface (Linux only) or even an UDP tunnel. <span style=\" font-weight:600;\">Please be aware that Wifi interfaces may not work properly.</span></p></body></html>"))
        self.uiAddEthernetPushButton.setText(_translate("cloudConfigPageWidget", "&Add"))
        self.uiAddAllEthernetPushButton.setText(_translate("cloudConfigPageWidget", "&Add all"))
@@ -272,9 +320,19 @@ class Ui_cloudConfigPageWidget(object):
        self.uiUDPTreeWidget.headerItem().setText(3, _translate("cloudConfigPageWidget", "Remote port"))
        self.uiTabWidget.setTabText(self.uiTabWidget.indexOf(self.UDPTab), _translate("cloudConfigPageWidget", "UDP tunnels"))
        self.uiNameLabel.setText(_translate("cloudConfigPageWidget", "Name:"))
+        self.uiConsoleHostLabel.setText(_translate("cloudConfigPageWidget", "Console host:"))
+        self.labeluiConsolePortLabel.setText(_translate("cloudConfigPageWidget", "Console port:"))
+        self.uiConsoleHttpPathLabel.setText(_translate("cloudConfigPageWidget", "Console HTTP path:"))
        self.uiDefaultNameFormatLabel.setText(_translate("cloudConfigPageWidget", "Default name format:"))
        self.uiSymbolLabel.setText(_translate("cloudConfigPageWidget", "Symbol:"))
        self.uiSymbolToolButton.setText(_translate("cloudConfigPageWidget", "&Browse..."))
        self.uiCategoryLabel.setText(_translate("cloudConfigPageWidget", "Category:"))
+        self.uiConsoleTypeLabel.setText(_translate("cloudConfigPageWidget", "Console type:"))
+        self.uiConsoleTypeComboBox.setItemText(0, _translate("cloudConfigPageWidget", "telnet"))
+        self.uiConsoleTypeComboBox.setItemText(1, _translate("cloudConfigPageWidget", "vnc"))
+        self.uiConsoleTypeComboBox.setItemText(2, _translate("cloudConfigPageWidget", "spice"))
+        self.uiConsoleTypeComboBox.setItemText(3, _translate("cloudConfigPageWidget", "http"))
+        self.uiConsoleTypeComboBox.setItemText(4, _translate("cloudConfigPageWidget", "https"))
+        self.uiConsoleTypeComboBox.setItemText(5, _translate("cloudConfigPageWidget", "none"))
        self.uiTabWidget.setTabText(self.uiTabWidget.indexOf(self.MiscTab), _translate("cloudConfigPageWidget", "Misc."))

--- a/gns3/modules/builtin/ui/cloud_preferences_page_ui.py
+++ b/gns3/modules/builtin/ui/cloud_preferences_page_ui.py
@@ -2,8 +2,7 @@

 # Form implementation generated from reading ui file '/home/grossmj/PycharmProjects/gns3-gui/gns3/modules/builtin/ui/cloud_preferences_page.ui'
 #
-# Created: Fri Jun 10 14:39:19 2016
-#      by: PyQt5 UI code generator 5.2.1
+# Created by: PyQt5 UI code generator 5.9
 #
 # WARNING! All changes made in this file will be lost!

--- a/gns3/modules/builtin/ui/cloud_wizard.ui
+++ b/gns3/modules/builtin/ui/cloud_wizard.ui
@@ -6,8 +6,8 @@
   <rect>
    <x>0</x>
    <y>0</y>
-    <width>585</width>
-    <height>423</height>
+    <width>670</width>
+    <height>452</height>
   </rect>
  </property>
  <property name="windowTitle">
@@ -21,7 +21,7 @@
    <string>Server</string>
   </property>
   <property name="subTitle">
-    <string>Please choose a server type to run your new cloud node.</string>
+    <string>Please choose a server type to run the cloud node.</string>
   </property>
   <layout class="QGridLayout" name="gridLayout_2">
    <item row="0" column="0">
--- a/gns3/modules/builtin/ui/cloud_wizard_ui.py
+++ b/gns3/modules/builtin/ui/cloud_wizard_ui.py
@@ -2,8 +2,7 @@

 # Form implementation generated from reading ui file '/home/grossmj/PycharmProjects/gns3-gui/gns3/modules/builtin/ui/cloud_wizard.ui'
 #
-# Created: Fri Jun 10 15:32:51 2016
-#      by: PyQt5 UI code generator 5.2.1
+# Created by: PyQt5 UI code generator 5.9
 #
 # WARNING! All changes made in this file will be lost!

@@ -12,7 +11,7 @@ from PyQt5 import QtCore, QtGui, QtWidgets
 class Ui_CloudNodeWizard(object):
    def setupUi(self, CloudNodeWizard):
        CloudNodeWizard.setObjectName("CloudNodeWizard")
-        CloudNodeWizard.resize(585, 423)
+        CloudNodeWizard.resize(670, 452)
        CloudNodeWizard.setModal(True)
        self.uiServerWizardPage = QtWidgets.QWizardPage()
        self.uiServerWizardPage.setObjectName("uiServerWizardPage")
@@ -70,7 +69,7 @@ class Ui_CloudNodeWizard(object):
        _translate = QtCore.QCoreApplication.translate
        CloudNodeWizard.setWindowTitle(_translate("CloudNodeWizard", "New cloud node template"))
        self.uiServerWizardPage.setTitle(_translate("CloudNodeWizard", "Server"))
-        self.uiServerWizardPage.setSubTitle(_translate("CloudNodeWizard", "Please choose a server type to run your new cloud node."))
+        self.uiServerWizardPage.setSubTitle(_translate("CloudNodeWizard", "Please choose a server type to run the cloud node."))
        self.uiServerTypeGroupBox.setTitle(_translate("CloudNodeWizard", "Server type"))
        self.uiRemoteRadioButton.setText(_translate("CloudNodeWizard", "Run the cloud node on a remote computers"))
        self.uiVMRadioButton.setText(_translate("CloudNodeWizard", "Run the cloud node on the GNS3 VM"))
--- a/gns3/modules/builtin/ui/ethernet_hub_configuration_page.ui
+++ b/gns3/modules/builtin/ui/ethernet_hub_configuration_page.ui
@@ -6,12 +6,12 @@
   <rect>
    <x>0</x>
    <y>0</y>
-    <width>507</width>
+    <width>591</width>
    <height>352</height>
   </rect>
  </property>
  <property name="windowTitle">
-   <string>Ethernet hub</string>
+   <string>Ethernet hub template configuration</string>
  </property>
  <layout class="QVBoxLayout" name="verticalLayout">
   <item>
--- a/gns3/modules/builtin/ui/ethernet_hub_configuration_page_ui.py
+++ b/gns3/modules/builtin/ui/ethernet_hub_configuration_page_ui.py
@@ -2,8 +2,7 @@

 # Form implementation generated from reading ui file '/home/grossmj/PycharmProjects/gns3-gui/gns3/modules/builtin/ui/ethernet_hub_configuration_page.ui'
 #
-# Created: Fri Jun 10 18:55:02 2016
-#      by: PyQt5 UI code generator 5.2.1
+# Created by: PyQt5 UI code generator 5.11.3
 #
 # WARNING! All changes made in this file will be lost!

@@ -12,7 +11,7 @@ from PyQt5 import QtCore, QtGui, QtWidgets
 class Ui_ethernetHubConfigPageWidget(object):
    def setupUi(self, ethernetHubConfigPageWidget):
        ethernetHubConfigPageWidget.setObjectName("ethernetHubConfigPageWidget")
-        ethernetHubConfigPageWidget.resize(507, 352)
+        ethernetHubConfigPageWidget.resize(591, 352)
        self.verticalLayout = QtWidgets.QVBoxLayout(ethernetHubConfigPageWidget)
        self.verticalLayout.setObjectName("verticalLayout")
        self.uiSettingsGroupBox = QtWidgets.QGroupBox(ethernetHubConfigPageWidget)
@@ -78,7 +77,7 @@ class Ui_ethernetHubConfigPageWidget(object):

    def retranslateUi(self, ethernetHubConfigPageWidget):
        _translate = QtCore.QCoreApplication.translate
-        ethernetHubConfigPageWidget.setWindowTitle(_translate("ethernetHubConfigPageWidget", "Ethernet hub"))
+        ethernetHubConfigPageWidget.setWindowTitle(_translate("ethernetHubConfigPageWidget", "Ethernet hub template configuration"))
        self.uiSettingsGroupBox.setTitle(_translate("ethernetHubConfigPageWidget", "Settings"))
        self.uiNameLabel.setText(_translate("ethernetHubConfigPageWidget", "Name:"))
        self.uiDefaultNameFormatLabel.setText(_translate("ethernetHubConfigPageWidget", "Default name format:"))
--- a/gns3/modules/builtin/ui/ethernet_hub_preferences_page_ui.py
+++ b/gns3/modules/builtin/ui/ethernet_hub_preferences_page_ui.py
@@ -2,8 +2,7 @@

 # Form implementation generated from reading ui file '/home/grossmj/PycharmProjects/gns3-gui/gns3/modules/builtin/ui/ethernet_hub_preferences_page.ui'
 #
-# Created: Fri Jun 10 17:15:20 2016
-#      by: PyQt5 UI code generator 5.2.1
+# Created by: PyQt5 UI code generator 5.9
 #
 # WARNING! All changes made in this file will be lost!

--- a/gns3/modules/builtin/ui/ethernet_hub_wizard.ui
+++ b/gns3/modules/builtin/ui/ethernet_hub_wizard.ui
@@ -6,8 +6,8 @@
   <rect>
    <x>0</x>
    <y>0</y>
-    <width>585</width>
-    <height>423</height>
+    <width>694</width>
+    <height>452</height>
   </rect>
  </property>
  <property name="windowTitle">
@@ -21,7 +21,7 @@
    <string>Server</string>
   </property>
   <property name="subTitle">
-    <string>Please choose a server type to run your new Ethernet hub.</string>
+    <string>Please choose a server type to run the Ethernet hub.</string>
   </property>
   <layout class="QGridLayout" name="gridLayout_2">
    <item row="0" column="0">
--- a/Show More
+++ b/Show More