General work on the Dynamips backend (need to finish and polish).

gns3server/modules/dynamips/backends/atmsw.py

@@ -0,0 +1,201 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import re
+from gns3server.modules import IModule
+from ..nodes.atm_switch import ATMSwitch
+from ..dynamips_error import DynamipsError
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class ATMSW(object):
+
+    @IModule.route("dynamips.atmsw.create")
+    def atmsw_create(self, request):
+        """
+        Creates a new ATM switch.
+
+        :param request: JSON request
+        """
+
+        name = None
+        if request and "name" in request:
+            name = request["name"]
+
+        try:
+            hypervisor = self._hypervisor_manager.allocate_hypervisor_for_switch()
+            atmsw = ATMSwitch(hypervisor, name)
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+
+        response = {"name": atmsw.name,
+                    "id": atmsw.id}
+
+        self._atm_switches[atmsw.id] = atmsw
+        self.send_response(response)
+
+    @IModule.route("dynamips.atmsw.delete")
+    def atmsw_delete(self, request):
+        """
+        Deletes a ATM switch.
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        atmsw_id = request["id"]
+        atmsw = self._atm_switches[atmsw_id]
+        try:
+            atmsw.delete()
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+        self.send_response(request)
+
+    @IModule.route("dynamips.atmsw.update")
+    def atmsw_update(self, request):
+        """
+        Updates a ATM switch.
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        atmsw_id = request["id"]
+        atmsw = self._atm_switches[atmsw_id]
+        self.send_response(request)
+
+    @IModule.route("dynamips.atmsw.allocate_udp_port")
+    def atmsw_allocate_udp_port(self, request):
+        """
+        Allocates a UDP port in order to create an UDP NIO for an
+        ATM switch.
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        atmsw_id = request["id"]
+        atmsw = self._atm_switches[atmsw_id]
+
+        try:
+            # allocate a new UDP port
+            response = self.allocate_udp_port(atmsw)
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+
+        self.send_response(response)
+
+    @IModule.route("dynamips.atmsw.add_nio")
+    def atmsw_add_nio(self, request):
+        """
+        Adds an NIO (Network Input/Output) for an ATM switch.
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        atmsw_id = request["id"]
+        atmsw = self._atm_switches[atmsw_id]
+
+        port = request["port"]
+        mapping = request["mapping"]
+
+        try:
+            nio = self.create_nio(atmsw, request)
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+
+        try:
+            atmsw.add_nio(nio, port)
+            pvc_entry = re.compile(r"""^([0-9]*):([0-9]*):([0-9]*)$""")
+            for source, destination in mapping.items():
+                match_source_pvc = pvc_entry.search(source)
+                match_destination_pvc = pvc_entry.search(destination)
+                if match_source_pvc and match_destination_pvc:
+                    # add the virtual channels mapped with this port/nio
+                    source_port, source_vpi, source_vci = map(int, match_source_pvc.group(1, 2, 3))
+                    destination_port, destination_vpi, destination_vci = map(int, match_destination_pvc.group(1, 2, 3))
+                    if atmsw.has_port(destination_port):
+                        if (source_port, source_vpi, source_vci) not in atmsw.mapping and \
+                           (destination_port, destination_vpi, destination_vci) not in atmsw.mapping:
+                            atmsw.map_pvc(source_port, source_vpi, source_vci, destination_port, destination_vpi, destination_vci)
+                            atmsw.map_pvc(destination_port, destination_vpi, destination_vci, source_port, source_vpi, source_vci)
+                else:
+                    # add the virtual paths mapped with this port/nio
+                    source_port, source_vpi = map(int, source.split(':'))
+                    destination_port, destination_vpi = map(int, destination.split(':'))
+                    if atmsw.has_port(destination_port):
+                        if (source_port, source_vpi) not in atmsw.mapping and (destination_port, destination_vpi) not in atmsw.mapping:
+                            atmsw.map_vp(source_port, source_vpi, destination_port, destination_vpi)
+                            atmsw.map_vp(destination_port, destination_vpi, source_port, source_vpi)
+
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+
+        # for now send back the original request
+        self.send_response(request)
+
+    @IModule.route("dynamips.atmsw.delete_nio")
+    def atmsw_delete_nio(self, request):
+        """
+        Deletes an NIO (Network Input/Output).
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        atmsw_id = request["id"]
+        atmsw = self._atm_switches[atmsw_id]
+        port = request["port"]
+
+        try:
+            for source, destination in atmsw.mapping.copy().items():
+                if len(source) == 3 and len(destination) == 3:
+                    # remove the virtual channels mapped with this port/nio
+                    source_port, source_vpi, source_vci = source
+                    destination_port, destination_vpi, destination_vci = destination
+                    if port == source_port:
+                        atmsw.unmap_pvc(source_port, source_vpi, source_vci, destination_port, destination_vpi, destination_vci)
+                        atmsw.unmap_pvc(destination_port, destination_vpi, destination_vci, source_port, source_vpi, source_vci)
+                else:
+                    # remove the virtual paths mapped with this port/nio
+                    source_port, source_vpi = source
+                    destination_port, destination_vpi = destination
+                    if port == source_port:
+                        atmsw.unmap_vp(source_port, source_vpi, destination_port, destination_vpi)
+                        atmsw.unmap_vp(destination_port, destination_vpi, source_port, source_vpi)
+
+            nio = atmsw.remove_nio(port)
+            nio.delete()
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+
+        # for now send back the original request
+        self.send_response(request)

gns3server/modules/dynamips/backends/ethhub.py

@@ -0,0 +1,162 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from gns3server.modules import IModule
+from ..nodes.hub import Hub
+from ..dynamips_error import DynamipsError
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class ETHHUB(object):
+
+    @IModule.route("dynamips.ethhub.create")
+    def ethhub_create(self, request):
+        """
+        Creates a new Ethernet switch.
+
+        :param request: JSON request
+        """
+
+        name = None
+        if request and "name" in request:
+            name = request["name"]
+
+        try:
+            hypervisor = self._hypervisor_manager.allocate_hypervisor_for_switch()
+            ethhub = Hub(hypervisor, name)
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+
+        response = {"name": ethhub.name,
+                    "id": ethhub.id}
+
+        self._ethernet_hubs[ethhub.id] = ethhub
+        self.send_response(response)
+
+    @IModule.route("dynamips.ethhub.delete")
+    def ethhub_delete(self, request):
+        """
+        Deletes a Ethernet hub.
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        ethhub_id = request["id"]
+        ethhub = self._ethernet_hubs[ethhub_id]
+        try:
+            ethhub.delete()
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+        self.send_response(request)
+
+    @IModule.route("dynamips.ethhub.update")
+    def ethhub_update(self, request):
+        """
+        Updates a Ethernet hub.
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        ethhub_id = request["id"]
+        ethhub = self._ethernet_hubs[ethhub_id]
+        #ports = request["ports"]
+
+        self.send_response(request)
+
+    @IModule.route("dynamips.ethhub.allocate_udp_port")
+    def ethhub_allocate_udp_port(self, request):
+        """
+        Allocates a UDP port in order to create an UDP NIO for an
+        Ethernet hub.
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        ethhub_id = request["id"]
+        ethhub = self._ethernet_hubs[ethhub_id]
+
+        try:
+            # allocate a new UDP port
+            response = self.allocate_udp_port(ethhub)
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+
+        self.send_response(response)
+
+    @IModule.route("dynamips.ethhub.add_nio")
+    def ethhub_add_nio(self, request):
+        """
+        Adds an NIO (Network Input/Output) for an Ethernet hub.
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        ethhub_id = request["id"]
+        ethhub = self._ethernet_hubs[ethhub_id]
+        port = request["port"]
+
+        try:
+            nio = self.create_nio(ethhub, request)
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+
+        try:
+            ethhub.add_nio(nio, port)
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+
+        # for now send back the original request
+        self.send_response(request)
+
+    @IModule.route("dynamips.ethhub.delete_nio")
+    def ethsw_delete_nio(self, request):
+        """
+        Deletes an NIO (Network Input/Output).
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        ethhub_id = request["id"]
+        ethhub = self._ethernet_hubs[ethhub_id]
+        port = request["port"]
+
+        try:
+            nio = ethhub.remove_nio(port)
+            nio.delete()
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+
+        # for now send back the original request
+        self.send_response(request)

gns3server/modules/dynamips/backends/ethsw.py

@@ -0,0 +1,180 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from gns3server.modules import IModule
+from ..nodes.ethernet_switch import EthernetSwitch
+from ..dynamips_error import DynamipsError
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class ETHSW(object):
+
+    @IModule.route("dynamips.ethsw.create")
+    def ethsw_create(self, request):
+        """
+        Creates a new Ethernet switch.
+
+        :param request: JSON request
+        """
+
+        name = None
+        if request and "name" in request:
+            name = request["name"]
+
+        try:
+            hypervisor = self._hypervisor_manager.allocate_hypervisor_for_switch()
+            ethsw = EthernetSwitch(hypervisor, name)
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+
+        response = {"name": ethsw.name,
+                    "id": ethsw.id}
+
+        self._ethernet_switches[ethsw.id] = ethsw
+        self.send_response(response)
+
+    @IModule.route("dynamips.ethsw.delete")
+    def ethsw_delete(self, request):
+        """
+        Deletes a Ethernet switch.
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        ethsw_id = request["id"]
+        ethsw = self._ethernet_switches[ethsw_id]
+        try:
+            ethsw.delete()
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+        self.send_response(request)
+
+    @IModule.route("dynamips.ethsw.update")
+    def ethsw_update(self, request):
+        """
+        Updates a Ethernet switch.
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        ethsw_id = request["id"]
+        ethsw = self._ethernet_switches[ethsw_id]
+        ports = request["ports"]
+
+        for port, info in ports.items():
+            vlan = info["vlan"]
+            port_type = info["type"]
+            if port_type == "access":
+                ethsw.set_access_port(int(port), vlan)
+            elif port_type == "dot1q":
+                ethsw.set_dot1q_port(int(port), vlan)
+            elif port_type == "qinq":
+                ethsw.set_qinq_port(int(port), vlan)
+
+        self.send_response(request)
+
+    @IModule.route("dynamips.ethsw.allocate_udp_port")
+    def ethsw_allocate_udp_port(self, request):
+        """
+        Allocates a UDP port in order to create an UDP NIO for an
+        Ethernet switch.
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        ethsw_id = request["id"]
+        ethsw = self._ethernet_switches[ethsw_id]
+
+        try:
+            # allocate a new UDP port
+            response = self.allocate_udp_port(ethsw)
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+
+        self.send_response(response)
+
+    @IModule.route("dynamips.ethsw.add_nio")
+    def ethsw_add_nio(self, request):
+        """
+        Adds an NIO (Network Input/Output) for an Ethernet switch.
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        ethsw_id = request["id"]
+        ethsw = self._ethernet_switches[ethsw_id]
+
+        port = request["port"]
+        vlan = request["vlan"]
+        port_type = request["port_type"]
+        try:
+            nio = self.create_nio(ethsw, request)
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+
+        try:
+            ethsw.add_nio(nio, port)
+            if port_type == "access":
+                ethsw.set_access_port(port, vlan)
+            elif port_type == "dot1q":
+                ethsw.set_dot1q_port(port, vlan)
+            elif port_type == "qinq":
+                ethsw.set_qinq_port(port, vlan)
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+
+        # for now send back the original request
+        self.send_response(request)
+
+    @IModule.route("dynamips.ethsw.delete_nio")
+    def ethsw_delete_nio(self, request):
+        """
+        Deletes an NIO (Network Input/Output).
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        ethsw_id = request["id"]
+        ethsw = self._ethernet_switches[ethsw_id]
+        port = request["port"]
+
+        try:
+            nio = ethsw.remove_nio(port)
+            nio.delete()
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+
+        # for now send back the original request
+        self.send_response(request)

gns3server/modules/dynamips/backends/frsw.py

@@ -0,0 +1,179 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from gns3server.modules import IModule
+from ..nodes.frame_relay_switch import FrameRelaySwitch
+from ..dynamips_error import DynamipsError
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class FRSW(object):
+
+    @IModule.route("dynamips.frsw.create")
+    def frsw_create(self, request):
+        """
+        Creates a new Frame-Relay switch.
+
+        :param request: JSON request
+        """
+
+        name = None
+        if request and "name" in request:
+            name = request["name"]
+
+        try:
+            hypervisor = self._hypervisor_manager.allocate_hypervisor_for_switch()
+            frsw = FrameRelaySwitch(hypervisor, name)
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+
+        response = {"name": frsw.name,
+                    "id": frsw.id}
+
+        self._frame_relay_switches[frsw.id] = frsw
+        self.send_response(response)
+
+    @IModule.route("dynamips.frsw.delete")
+    def frsw_delete(self, request):
+        """
+        Deletes a Frame Relay switch.
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        frsw_id = request["id"]
+        frsw = self._frame_relay_switches[frsw_id]
+        try:
+            frsw.delete()
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+        self.send_response(request)
+
+    @IModule.route("dynamips.frsw.update")
+    def frsw_update(self, request):
+        """
+        Updates a Frame Relay switch.
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        frsw_id = request["id"]
+        frsw = self._frame_relay_switches[frsw_id]
+        self.send_response(request)
+
+    @IModule.route("dynamips.frsw.allocate_udp_port")
+    def frsw_allocate_udp_port(self, request):
+        """
+        Allocates a UDP port in order to create an UDP NIO for an
+        Frame Relay switch.
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        frsw_id = request["id"]
+        frsw = self._frame_relay_switches[frsw_id]
+
+        try:
+            # allocate a new UDP port
+            response = self.allocate_udp_port(frsw)
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+
+        self.send_response(response)
+
+    @IModule.route("dynamips.frsw.add_nio")
+    def frsw_add_nio(self, request):
+        """
+        Adds an NIO (Network Input/Output) for an Frame-Relay switch.
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        frsw_id = request["id"]
+        frsw = self._frame_relay_switches[frsw_id]
+
+        port = request["port"]
+        mapping = request["mapping"]
+
+        try:
+            nio = self.create_nio(frsw, request)
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+
+        try:
+            frsw.add_nio(nio, port)
+
+            # add the VCs mapped with this port/nio
+            for source, destination in mapping.items():
+                source_port, source_dlci = map(int, source.split(':'))
+                destination_port, destination_dlci = map(int, destination.split(':'))
+                if frsw.has_port(destination_port):
+                    if (source_port, source_dlci) not in frsw.mapping and (destination_port, destination_dlci) not in frsw.mapping:
+                        frsw.map_vc(source_port, source_dlci, destination_port, destination_dlci)
+                        frsw.map_vc(destination_port, destination_dlci, source_port, source_dlci)
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+
+        # for now send back the original request
+        self.send_response(request)
+
+    @IModule.route("dynamips.frsw.delete_nio")
+    def frsw_delete_nio(self, request):
+        """
+        Deletes an NIO (Network Input/Output).
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        frsw_id = request["id"]
+        frsw = self._frame_relay_switches[frsw_id]
+        port = request["port"]
+
+        try:
+            # remove the VCs mapped with this port/nio
+            for source, destination in frsw.mapping.copy().items():
+                source_port, source_dlci = source
+                destination_port, destination_dlci = destination
+                if port == source_port:
+                    frsw.unmap_vc(source_port, source_dlci, destination_port, destination_dlci)
+                    frsw.unmap_vc(destination_port, destination_dlci, source_port, source_dlci)
+
+            nio = frsw.remove_nio(port)
+            nio.delete()
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+
+        # for now send back the original request
+        self.send_response(request)

gns3server/modules/dynamips/backends/vm.py

@@ -0,0 +1,367 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import os
+from gns3server.modules import IModule
+from ..dynamips_error import DynamipsError
+
+from ..nodes.c1700 import C1700
+from ..nodes.c2600 import C2600
+from ..nodes.c2691 import C2691
+from ..nodes.c3600 import C3600
+from ..nodes.c3725 import C3725
+from ..nodes.c3745 import C3745
+from ..nodes.c7200 import C7200
+
+from ..adapters.c7200_io_2fe import C7200_IO_2FE
+from ..adapters.c7200_io_fe import C7200_IO_FE
+from ..adapters.c7200_io_ge_e import C7200_IO_GE_E
+from ..adapters.nm_16esw import NM_16ESW
+from ..adapters.nm_1e import NM_1E
+from ..adapters.nm_1fe_tx import NM_1FE_TX
+from ..adapters.nm_4e import NM_4E
+from ..adapters.nm_4t import NM_4T
+from ..adapters.pa_2fe_tx import PA_2FE_TX
+from ..adapters.pa_4e import PA_4E
+from ..adapters.pa_4t import PA_4T
+from ..adapters.pa_8e import PA_8E
+from ..adapters.pa_8t import PA_8T
+from ..adapters.pa_a1 import PA_A1
+from ..adapters.pa_fe_tx import PA_FE_TX
+from ..adapters.pa_ge import PA_GE
+from ..adapters.pa_pos_oc3 import PA_POS_OC3
+from ..adapters.wic_1enet import WIC_1ENET
+from ..adapters.wic_1t import WIC_1T
+from ..adapters.wic_2t import WIC_2T
+
+import logging
+log = logging.getLogger(__name__)
+
+
+ADAPTER_MATRIX = {"C7200_IO_2FE": C7200_IO_2FE,
+                  "C7200_IO_FE": C7200_IO_FE,
+                  "C7200-IO-GE-E": C7200_IO_GE_E,
+                  "NM-16ESW": NM_16ESW,
+                  "NM-1E": NM_1E,
+                  "NM-1FE-TX": NM_1FE_TX,
+                  "NM-4E": NM_4E,
+                  "NM-4T": NM_4T,
+                  "PA-2FE-TX": PA_2FE_TX,
+                  "PA-4E": PA_4E,
+                  "PA-4T+": PA_4T,
+                  "PA-8E": PA_8E,
+                  "PA-8T": PA_8T,
+                  "PA-A1": PA_A1,
+                  "PA-FE-TX": PA_FE_TX,
+                  "PA-GE": PA_GE,
+                  "PA-POS-OC3": PA_POS_OC3}
+
+WIC_MATRIX = {"WIC-1ENET": WIC_1ENET,
+              "WIC-1T": WIC_1T,
+              "WIC-2T": WIC_2T}
+
+PLATFORMS = {'c1700': C1700,
+             'c2600': C2600,
+             'c2691': C2691,
+             'c3725': C3725,
+             'c3745': C3745,
+             'c3600': C3600,
+             'c7200': C7200}
+
+
+class VM(object):
+
+    @IModule.route("dynamips.vm.create")
+    def vm_create(self, request):
+        """
+        Creates a new VM (router).
+
+        :param request: JSON request
+        """
+
+        if request == None:
+            self.send_param_error()
+        else:
+            log.debug("received request {}".format(request))
+
+            #TODO: JSON schema validation
+            #name = request["name"]
+            platform = request["platform"]
+            image = request["image"]
+            ram = request["ram"]
+
+            try:
+                hypervisor = self._hypervisor_manager.allocate_hypervisor_for_router(image, ram)
+                router = PLATFORMS[platform](hypervisor)
+                router.ram = ram
+                router.image = image
+                router.sparsemem = self._hypervisor_manager.sparse_memory_support
+                router.mmap = self._hypervisor_manager.mmap_support
+
+                # JIT sharing support
+                if self._hypervisor_manager.jit_sharing_support:
+                    jitsharing_groups = hypervisor.jitsharing_groups
+                    ios_image = os.path.basename(image)
+                    if ios_image in jitsharing_groups:
+                        router.jit_sharing_group = jitsharing_groups[ios_image]
+                    else:
+                        new_jit_group = -1
+                        for jit_group in range(0, 127):
+                            if jit_group not in jitsharing_groups.values():
+                                new_jit_group = jit_group
+                                break
+                        if new_jit_group == -1:
+                            raise DynamipsError("All JIT groups are allocated!")
+                        router.jit_sharing_group = new_jit_group
+
+                # Ghost IOS support
+                if self._hypervisor_manager.ghost_ios_support:
+                    self.set_ghost_ios(router)
+
+            except DynamipsError as e:
+                hypervisor.decrease_memory_load(ram)
+                if hypervisor.memory_load == 0 and not hypervisor.devices:
+                    hypervisor.stop()
+                    self._hypervisor_manager.hypervisors.remove(hypervisor)
+                self.send_custom_error(str(e))
+                return
+
+            response = {"name": router.name,
+                        "id": router.id}
+            defaults = router.defaults()
+            response.update(defaults)
+            self._routers[router.id] = router
+            self.send_response(response)
+
+    @IModule.route("dynamips.vm.delete")
+    def vm_delete(self, request):
+        """
+        Deletes a VM (router).
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        router_id = request["id"]
+        router = self._routers[router_id]
+        try:
+            router.delete()
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+        self.send_response(request)
+
+    @IModule.route("dynamips.vm.start")
+    def vm_start(self, request):
+        """
+        Starts a VM (router)
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        router_id = request["id"]
+        router = self._routers[router_id]
+        try:
+            router.start()
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+        self.send_response(request)
+
+    @IModule.route("dynamips.vm.stop")
+    def vm_stop(self, request):
+        """
+        Stops a VM (router)
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        router_id = request["id"]
+        router = self._routers[router_id]
+        try:
+            router.stop()
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+        self.send_response(request)
+
+    @IModule.route("dynamips.vm.suspend")
+    def vm_suspend(self, request):
+        """
+        Suspends a VM (router)
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        router_id = request["id"]
+        router = self._routers[router_id]
+        try:
+            router.suspend()
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+        self.send_response(request)
+
+    @IModule.route("dynamips.vm.update")
+    def vm_update(self, request):
+        """
+        Updates settings for a VM (router).
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        router_id = request["id"]
+        router = self._routers[router_id]
+
+        # update the settings
+        for name, value in request.items():
+            if hasattr(router, name) and getattr(router, name) != value:
+                try:
+                    setattr(router, name, value)
+                except DynamipsError as e:
+                    self.send_custom_error(str(e))
+                    return
+            elif name.startswith("slot") and value in ADAPTER_MATRIX:
+                slot_id = int(name[-1])
+                adapter_name = value
+                adapter = ADAPTER_MATRIX[adapter_name]()
+                try:
+                    if router.slots[slot_id] and type(router.slots[slot_id]) != type(adapter):
+                        router.slot_remove_binding(slot_id)
+                    router.slot_add_binding(slot_id, adapter)
+                except DynamipsError as e:
+                    self.send_custom_error(str(e))
+                    return
+            elif name.startswith("slot") and value == None:
+                slot_id = int(name[-1])
+                if router.slots[slot_id]:
+                    try:
+                        router.slot_remove_binding(slot_id)
+                    except:
+                        self.send_custom_error(str(e))
+                        return
+            elif name.startswith("wic") and value in WIC_MATRIX:
+                wic_slot_id = int(name[-1])
+                wic_name = value
+                wic = WIC_MATRIX[wic_name]()
+                try:
+                    if router.slots[0].wics[wic_slot_id] and type(router.slots[0].wics[wic_slot_id]) != type(wic):
+                        router.uninstall_wic(wic_slot_id)
+                    router.install_wic(wic_slot_id, wic)
+                except DynamipsError as e:
+                    self.send_custom_error(str(e))
+                    return
+            elif name.startswith("wic") and value == None:
+                wic_slot_id = int(name[-1])
+                if router.slots[0].wics and router.slots[0].wics[wic_slot_id]:
+                    router.uninstall_wic(wic_slot_id)
+
+        # Update the ghost IOS file in case the RAM size has changed
+        if self._hypervisor_manager.ghost_ios_support:
+            self.set_ghost_ios(router)
+
+        # for now send back the original request
+        self.send_response(request)
+
+    @IModule.route("dynamips.vm.allocate_udp_port")
+    def vm_allocate_udp_port(self, request):
+        """
+        Allocates a UDP port in order to create an UDP NIO.
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        router_id = request["id"]
+        router = self._routers[router_id]
+
+        try:
+            # allocate a new UDP port
+            response = self.allocate_udp_port(router)
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+
+        self.send_response(response)
+
+    @IModule.route("dynamips.vm.add_nio")
+    def vm_add_nio(self, request):
+        """
+        Adds an NIO (Network Input/Output) for a VM (router).
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        router_id = request["id"]
+        router = self._routers[router_id]
+
+        slot = request["slot"]
+        port = request["port"]
+
+        print(request)
+
+        try:
+            nio = self.create_nio(router, request)
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+
+        try:
+            router.slot_add_nio_binding(slot, port, nio)
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+
+        # for now send back the original request
+        self.send_response(request)
+
+    @IModule.route("dynamips.vm.delete_nio")
+    def vm_delete_nio(self, request):
+        """
+        Deletes an NIO (Network Input/Output).
+
+        :param request: JSON request
+        """
+
+        #TODO: JSON schema validation for the request
+        log.debug("received request {}".format(request))
+        router_id = request["id"]
+        router = self._routers[router_id]
+        slot = request["slot"]
+        port = request["port"]
+
+        try:
+            nio = router.slot_remove_nio_binding(slot, port)
+            nio.delete()
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+
+        # for now send back the original request
+        self.send_response(request)