json-schema validations.

NIO creation refactoring.

gns3server/modules/dynamips/backends/atmsw.py

@@ -20,6 +20,13 @@ from gns3server.modules import IModule
 from ..nodes.atm_switch import ATMSwitch
 from ..dynamips_error import DynamipsError
 
+from ..schemas.atmsw import ATMSW_CREATE_SCHEMA
+from ..schemas.atmsw import ATMSW_DELETE_SCHEMA
+from ..schemas.atmsw import ATMSW_UPDATE_SCHEMA
+from ..schemas.atmsw import ATMSW_ALLOCATE_UDP_PORT_SCHEMA
+from ..schemas.atmsw import ATMSW_ADD_NIO_SCHEMA
+from ..schemas.atmsw import ATMSW_DELETE_NIO_SCHEMA
+
 import logging
 log = logging.getLogger(__name__)
 
@@ -41,7 +48,10 @@ class ATMSW(object):
         :param request: JSON request
         """
 
-        #TODO: JSON schema validation for the request
+        # validate the request
+        if request and not self.validate_request(request, ATMSW_CREATE_SCHEMA):
+            return
+
         name = None
         if request and "name" in request:
             name = request["name"]
@@ -71,22 +81,20 @@ class ATMSW(object):
         - id (switch identifier)
 
         Response parameters:
-        - same as original request
+        - True on success
 
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, ATMSW_DELETE_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
+        # get the ATM switch instance
         atmsw_id = request["id"]
-        if atmsw_id not in self._atm_switches:
-            self.send_custom_error("ATM switch id {} doesn't exist".format(atmsw_id))
+        atmsw = self.get_device_instance(atmsw_id, self._atm_switches)
+        if not atmsw:
             return
-        atmsw = self._atm_switches[atmsw_id]
 
         try:
             atmsw.delete()
@@ -95,7 +103,7 @@ class ATMSW(object):
         except DynamipsError as e:
             self.send_custom_error(str(e))
             return
-        self.send_response(request)
+        self.send_response(True)
 
     @IModule.route("dynamips.atmsw.update")
     def atmsw_update(self, request):
@@ -109,32 +117,31 @@ class ATMSW(object):
         - name (new switch name)
 
         Response parameters:
-        - same as original request
+        - name if changed
 
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, ATMSW_UPDATE_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        atmsw_id = request["id"]
-        if atmsw_id not in self._atm_switches:
-            self.send_custom_error("ATM switch id {} doesn't exist".format(atmsw_id))
+        # get the ATM switch instance
+        atmsw = self.get_device_instance(request["id"], self._atm_switches)
+        if not atmsw:
             return
-        atmsw = self._atm_switches[atmsw_id]
 
+        response = {}
         # rename the switch if requested
         if "name" in request and atmsw.name != request["name"]:
             try:
                 atmsw.name = request["name"]
+                response["name"] = atmsw.name
             except DynamipsError as e:
                 self.send_custom_error(str(e))
                 return
 
-        self.send_response(request)
+        self.send_response(response)
 
     @IModule.route("dynamips.atmsw.allocate_udp_port")
     def atmsw_allocate_udp_port(self, request):
@@ -153,17 +160,14 @@ class ATMSW(object):
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, ATMSW_ALLOCATE_UDP_PORT_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        atmsw_id = request["id"]
-        if atmsw_id not in self._atm_switches:
-            self.send_custom_error("ATM switch id {} doesn't exist".format(atmsw_id))
+        # get the ATM switch instance
+        atmsw = self.get_device_instance(request["id"], self._atm_switches)
+        if not atmsw:
             return
-        atmsw = self._atm_switches[atmsw_id]
 
         try:
             # allocate a new UDP port
@@ -185,42 +189,39 @@ class ATMSW(object):
         - port (port identifier)
         - port_id (port identifier)
         - mappings (VCs/VPs mapped to the port)
-        - nio (nio type, one of the following)
-            - "NIO_UDP"
+        - nio (one of the following)
+            - type "nio_udp"
                 - lport (local port)
                 - rhost (remote host)
                 - rport (remote port)
-            - "NIO_GenericEthernet"
+            - type "nio_generic_ethernet"
                 - ethernet_device (Ethernet device name e.g. eth0)
-            - "NIO_LinuxEthernet"
+            - type "nio_linux_ethernet"
                 - ethernet_device (Ethernet device name e.g. eth0)
-            - "NIO_TAP"
+            - type "nio_tap"
                 - tap_device (TAP device name e.g. tap0)
-            - "NIO_UNIX"
+            - type "nio_unix"
                 - local_file (path to UNIX socket file)
                 - remote_file (path to UNIX socket file)
-            - "NIO_VDE"
+            - type "nio_vde"
                 - control_file (path to VDE control file)
                 - local_file (path to VDE local file)
-            - "NIO_Null"
+            - type "nio_null"
 
         Response parameters:
-        - same as original request
+        - port_id (unique port identifier)
 
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, ATMSW_ADD_NIO_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        atmsw_id = request["id"]
-        if atmsw_id not in self._atm_switches:
-            self.send_custom_error("ATM switch id {} doesn't exist".format(atmsw_id))
+        # get the ATM switch instance
+        atmsw = self.get_device_instance(request["id"], self._atm_switches)
+        if not atmsw:
             return
-        atmsw = self._atm_switches[atmsw_id]
 
         port = request["port"]
         mappings = request["mappings"]
@@ -261,8 +262,7 @@ class ATMSW(object):
             self.send_custom_error(str(e))
             return
 
-        # for now send back the original request
-        self.send_response(request)
+        self.send_response({"port_id": request["port_id"]})
 
     @IModule.route("dynamips.atmsw.delete_nio")
     def atmsw_delete_nio(self, request):
@@ -274,24 +274,21 @@ class ATMSW(object):
         - port (port identifier)
 
         Response parameters:
-        - same as original request
+        - True on success
 
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, ATMSW_DELETE_NIO_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        atmsw_id = request["id"]
-        if atmsw_id not in self._atm_switches:
-            self.send_custom_error("ATM switch id {} doesn't exist".format(atmsw_id))
+        # get the ATM switch instance
+        atmsw = self.get_device_instance(request["id"], self._atm_switches)
+        if not atmsw:
             return
-        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:
@@ -315,5 +312,4 @@ class ATMSW(object):
             self.send_custom_error(str(e))
             return
 
-        # for now send back the original request
-        self.send_response(request)
+        self.send_response(True)

gns3server/modules/dynamips/backends/ethhub.py

@@ -19,6 +19,13 @@ from gns3server.modules import IModule
 from ..nodes.hub import Hub
 from ..dynamips_error import DynamipsError
 
+from ..schemas.ethhub import ETHHUB_CREATE_SCHEMA
+from ..schemas.ethhub import ETHHUB_DELETE_SCHEMA
+from ..schemas.ethhub import ETHHUB_UPDATE_SCHEMA
+from ..schemas.ethhub import ETHHUB_ALLOCATE_UDP_PORT_SCHEMA
+from ..schemas.ethhub import ETHHUB_ADD_NIO_SCHEMA
+from ..schemas.ethhub import ETHHUB_DELETE_NIO_SCHEMA
+
 import logging
 log = logging.getLogger(__name__)
 
@@ -40,7 +47,10 @@ class ETHHUB(object):
         :param request: JSON request
         """
 
-        #TODO: JSON schema validation for the request
+        # validate the request
+        if request and not self.validate_request(request, ETHHUB_CREATE_SCHEMA):
+            return
+
         name = None
         if request and "name" in request:
             name = request["name"]
@@ -70,22 +80,20 @@ class ETHHUB(object):
         - id (hub identifier)
 
         Response parameters:
-        - same as original request
+        - True on success
 
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, ETHHUB_DELETE_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
+        # get the Ethernet hub instance
         ethhub_id = request["id"]
-        if ethhub_id not in self._ethernet_hubs:
-            self.send_custom_error("Ethernet hub id {} doesn't exist".format(ethhub_id))
+        ethhub = self.get_device_instance(ethhub_id, self._ethernet_hubs)
+        if not ethhub:
             return
-        ethhub = self._ethernet_hubs[ethhub_id]
 
         try:
             ethhub.delete()
@@ -108,27 +116,26 @@ class ETHHUB(object):
         - name (new hub name)
 
         Response parameters:
-        - same as original request
+        - name if changed
 
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, ETHHUB_UPDATE_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        ethhub_id = request["id"]
-        if ethhub_id not in self._ethernet_hubs:
-            self.send_custom_error("Ethernet hub id {} doesn't exist".format(ethhub_id))
+        # get the Ethernet hub instance
+        ethhub = self.get_device_instance(request["id"], self._ethernet_hubs)
+        if not ethhub:
             return
-        ethhub = self._ethernet_hubs[ethhub_id]
 
+        response = {}
         # rename the hub if requested
         if "name" in request and ethhub.name != request["name"]:
             try:
                 ethhub.name = request["name"]
+                response["name"] = ethhub.name
             except DynamipsError as e:
                 self.send_custom_error(str(e))
                 return
@@ -152,17 +159,14 @@ class ETHHUB(object):
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, ETHHUB_ALLOCATE_UDP_PORT_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        ethhub_id = request["id"]
-        if ethhub_id not in self._ethernet_hubs:
-            self.send_custom_error("Ethernet hub id {} doesn't exist".format(ethhub_id))
+        # get the Ethernet hub instance
+        ethhub = self.get_device_instance(request["id"], self._ethernet_hubs)
+        if not ethhub:
             return
-        ethhub = self._ethernet_hubs[ethhub_id]
 
         try:
             # allocate a new UDP port
@@ -183,44 +187,41 @@ class ETHHUB(object):
         - id (hub identifier)
         - port (port identifier)
         - port_id (port identifier)
-        - nio (nio type, one of the following)
-            - "NIO_UDP"
+        - nio (one of the following)
+            - type "nio_udp"
                 - lport (local port)
                 - rhost (remote host)
                 - rport (remote port)
-            - "NIO_GenericEthernet"
+            - type "nio_generic_ethernet"
                 - ethernet_device (Ethernet device name e.g. eth0)
-            - "NIO_LinuxEthernet"
+            - type "nio_linux_ethernet"
                 - ethernet_device (Ethernet device name e.g. eth0)
-            - "NIO_TAP"
+            - type "nio_tap"
                 - tap_device (TAP device name e.g. tap0)
-            - "NIO_UNIX"
+            - type "nio_unix"
                 - local_file (path to UNIX socket file)
                 - remote_file (path to UNIX socket file)
-            - "NIO_VDE"
+            - type "nio_vde"
                 - control_file (path to VDE control file)
                 - local_file (path to VDE local file)
-            - "NIO_Null"
+            - type "nio_null"
 
         Response parameters:
-        - same as original request
+        - port_id (unique port identifier)
 
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, ETHHUB_ADD_NIO_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        ethhub_id = request["id"]
-        if ethhub_id not in self._ethernet_hubs:
-            self.send_custom_error("Ethernet hub id {} doesn't exist".format(ethhub_id))
+        # get the Ethernet hub instance
+        ethhub = self.get_device_instance(request["id"], self._ethernet_hubs)
+        if not ethhub:
             return
-        ethhub = self._ethernet_hubs[ethhub_id]
+
         port = request["port"]
-
         try:
             nio = self.create_nio(ethhub, request)
             if not nio:
@@ -235,8 +236,7 @@ class ETHHUB(object):
             self.send_custom_error(str(e))
             return
 
-        # for now send back the original request
-        self.send_response(request)
+        self.send_response({"port_id": request["port_id"]})
 
     @IModule.route("dynamips.ethhub.delete_nio")
     def ethsw_delete_nio(self, request):
@@ -248,24 +248,21 @@ class ETHHUB(object):
         - port (port identifier)
 
         Response parameters:
-        - same as original request
+        - True on success
 
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, ETHHUB_DELETE_NIO_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        ethhub_id = request["id"]
-        if ethhub_id not in self._ethernet_hubs:
-            self.send_custom_error("Ethernet hub id {} doesn't exist".format(ethhub_id))
+        # get the Ethernet hub instance
+        ethhub = self.get_device_instance(request["id"], self._ethernet_hubs)
+        if not ethhub:
             return
-        ethhub = self._ethernet_hubs[ethhub_id]
+
         port = request["port"]
-
         try:
             nio = ethhub.remove_nio(port)
             nio.delete()
@@ -273,5 +270,4 @@ class ETHHUB(object):
             self.send_custom_error(str(e))
             return
 
-        # for now send back the original request
-        self.send_response(request)
+        self.send_response(True)

gns3server/modules/dynamips/backends/ethsw.py

@@ -19,6 +19,13 @@ from gns3server.modules import IModule
 from ..nodes.ethernet_switch import EthernetSwitch
 from ..dynamips_error import DynamipsError
 
+from ..schemas.ethsw import ETHSW_CREATE_SCHEMA
+from ..schemas.ethsw import ETHSW_DELETE_SCHEMA
+from ..schemas.ethsw import ETHSW_UPDATE_SCHEMA
+from ..schemas.ethsw import ETHSW_ALLOCATE_UDP_PORT_SCHEMA
+from ..schemas.ethsw import ETHSW_ADD_NIO_SCHEMA
+from ..schemas.ethsw import ETHSW_DELETE_NIO_SCHEMA
+
 import logging
 log = logging.getLogger(__name__)
 
@@ -40,7 +47,10 @@ class ETHSW(object):
         :param request: JSON request
         """
 
-        #TODO: JSON schema validation for the request
+        # validate the request
+        if request and not self.validate_request(request, ETHSW_CREATE_SCHEMA):
+            return
+
         name = None
         if request and "name" in request:
             name = request["name"]
@@ -70,22 +80,20 @@ class ETHSW(object):
         - id (switch identifier)
 
         Response parameters:
-        - same as original request
+        - True on success
 
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, ETHSW_DELETE_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
+        # get the Ethernet switch instance
         ethsw_id = request["id"]
-        if ethsw_id not in self._ethernet_switches:
-            self.send_custom_error("Ethernet switch id {} doesn't exist".format(ethsw_id))
+        ethsw = self.get_device_instance(ethsw_id, self._ethernet_switches)
+        if not ethsw:
             return
-        ethsw = self._ethernet_switches[ethsw_id]
 
         try:
             ethsw.delete()
@@ -94,7 +102,7 @@ class ETHSW(object):
         except DynamipsError as e:
             self.send_custom_error(str(e))
             return
-        self.send_response(request)
+        self.send_response(True)
 
     @IModule.route("dynamips.ethsw.update")
     def ethsw_update(self, request):
@@ -109,22 +117,19 @@ class ETHSW(object):
         - ports (ports settings)
 
         Response parameters:
-        - same as original request
+        - name if changed
 
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, ETHSW_UPDATE_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        ethsw_id = request["id"]
-        if ethsw_id not in self._ethernet_switches:
-            self.send_custom_error("Ethernet switch id {} doesn't exist".format(ethsw_id))
+        # get the Ethernet switch instance
+        ethsw = self.get_device_instance(request["id"], self._ethernet_switches)
+        if not ethsw:
             return
-        ethsw = self._ethernet_switches[ethsw_id]
 
         if "ports" in request:
             ports = request["ports"]
@@ -144,15 +149,17 @@ class ETHSW(object):
                     self.send_custom_error(str(e))
                     return
 
+        response = {}
         # rename the switch if requested
         if "name" in request and ethsw.name != request["name"]:
             try:
                 ethsw.name = request["name"]
+                response["name"] = ethsw.name
             except DynamipsError as e:
                 self.send_custom_error(str(e))
                 return
 
-        self.send_response(request)
+        self.send_response(response)
 
     @IModule.route("dynamips.ethsw.allocate_udp_port")
     def ethsw_allocate_udp_port(self, request):
@@ -171,17 +178,14 @@ class ETHSW(object):
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, ETHSW_ALLOCATE_UDP_PORT_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        ethsw_id = request["id"]
-        if ethsw_id not in self._ethernet_switches:
-            self.send_custom_error("Ethernet switch id {} doesn't exist".format(ethsw_id))
+        # get the Ethernet switch instance
+        ethsw = self.get_device_instance(request["id"], self._ethernet_switches)
+        if not ethsw:
             return
-        ethsw = self._ethernet_switches[ethsw_id]
 
         try:
             # allocate a new UDP port
@@ -204,42 +208,39 @@ class ETHSW(object):
         - port_id (port identifier)
         - vlan (vlan identifier)
         - port_type ("access", "dot1q" or "qinq")
-        - nio (nio type, one of the following)
-            - "NIO_UDP"
+        - nio (one of the following)
+            - type "nio_udp"
                 - lport (local port)
                 - rhost (remote host)
                 - rport (remote port)
-            - "NIO_GenericEthernet"
+            - type "nio_generic_ethernet"
                 - ethernet_device (Ethernet device name e.g. eth0)
-            - "NIO_LinuxEthernet"
+            - type "nio_linux_ethernet"
                 - ethernet_device (Ethernet device name e.g. eth0)
-            - "NIO_TAP"
+            - type "nio_tap"
                 - tap_device (TAP device name e.g. tap0)
-            - "NIO_UNIX"
+            - type "nio_unix"
                 - local_file (path to UNIX socket file)
                 - remote_file (path to UNIX socket file)
-            - "NIO_VDE"
+            - type "nio_vde"
                 - control_file (path to VDE control file)
                 - local_file (path to VDE local file)
-            - "NIO_Null"
+            - type "nio_null"
 
         Response parameters:
-        - same as original request
+        - port_id (unique port identifier)
 
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, ETHSW_ADD_NIO_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        ethsw_id = request["id"]
-        if ethsw_id not in self._ethernet_switches:
-            self.send_custom_error("Ethernet switch id {} doesn't exist".format(ethsw_id))
+        # get the Ethernet switch instance
+        ethsw = self.get_device_instance(request["id"], self._ethernet_switches)
+        if not ethsw:
             return
-        ethsw = self._ethernet_switches[ethsw_id]
 
         port = request["port"]
         vlan = request["vlan"]
@@ -264,8 +265,7 @@ class ETHSW(object):
             self.send_custom_error(str(e))
             return
 
-        # for now send back the original request
-        self.send_response(request)
+        self.send_response({"port_id": request["port_id"]})
 
     @IModule.route("dynamips.ethsw.delete_nio")
     def ethsw_delete_nio(self, request):
@@ -277,24 +277,21 @@ class ETHSW(object):
         - port (port identifier)
 
         Response parameters:
-        - same as original request
+        - True on success
 
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, ETHSW_DELETE_NIO_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        ethsw_id = request["id"]
-        if ethsw_id not in self._ethernet_switches:
-            self.send_custom_error("Ethernet switch id {} doesn't exist".format(ethsw_id))
+        # get the Ethernet switch instance
+        ethsw = self.get_device_instance(request["id"], self._ethernet_switches)
+        if not ethsw:
             return
-        ethsw = self._ethernet_switches[ethsw_id]
+
         port = request["port"]
-
         try:
             nio = ethsw.remove_nio(port)
             nio.delete()
@@ -302,5 +299,4 @@ class ETHSW(object):
             self.send_custom_error(str(e))
             return
 
-        # for now send back the original request
-        self.send_response(request)
+        self.send_response(True)

gns3server/modules/dynamips/backends/frsw.py

@@ -19,6 +19,13 @@ from gns3server.modules import IModule
 from ..nodes.frame_relay_switch import FrameRelaySwitch
 from ..dynamips_error import DynamipsError
 
+from ..schemas.frsw import FRSW_CREATE_SCHEMA
+from ..schemas.frsw import FRSW_DELETE_SCHEMA
+from ..schemas.frsw import FRSW_UPDATE_SCHEMA
+from ..schemas.frsw import FRSW_ALLOCATE_UDP_PORT_SCHEMA
+from ..schemas.frsw import FRSW_ADD_NIO_SCHEMA
+from ..schemas.frsw import FRSW_DELETE_NIO_SCHEMA
+
 import logging
 log = logging.getLogger(__name__)
 
@@ -40,7 +47,10 @@ class FRSW(object):
         :param request: JSON request
         """
 
-        #TODO: JSON schema validation for the request
+        # validate the request
+        if request and not self.validate_request(request, FRSW_CREATE_SCHEMA):
+            return
+
         name = None
         if request and "name" in request:
             name = request["name"]
@@ -70,22 +80,20 @@ class FRSW(object):
         - id (switch identifier)
 
         Response parameters:
-        - same as original request
+        - True on success
 
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, FRSW_DELETE_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
+        # get the Frame relay switch instance
         frsw_id = request["id"]
-        if frsw_id not in self._frame_relay_switches:
-            self.send_custom_error("Frame relay switch id {} doesn't exist".format(frsw_id))
+        frsw = self.get_device_instance(frsw_id, self._frame_relay_switches)
+        if not frsw:
             return
-        frsw = self._frame_relay_switches[frsw_id]
 
         try:
             frsw.delete()
@@ -94,7 +102,8 @@ class FRSW(object):
         except DynamipsError as e:
             self.send_custom_error(str(e))
             return
-        self.send_response(request)
+
+        self.send_response(True)
 
     @IModule.route("dynamips.frsw.update")
     def frsw_update(self, request):
@@ -108,30 +117,30 @@ class FRSW(object):
         - name (new switch name)
 
         Response parameters:
-        - same as original request
+        - name if updated
 
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, FRSW_UPDATE_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        frsw_id = request["id"]
-        if frsw_id not in self._frame_relay_switches:
-            self.send_custom_error("Frame relay switch id {} doesn't exist".format(frsw_id))
+        # get the Frame relay switch instance
+        frsw = self.get_device_instance(request["id"], self._frame_relay_switches)
+        if not frsw:
             return
-        frsw = self._frame_relay_switches[frsw_id]
 
+        response = {}
         # rename the switch if requested
         if "name" in request and frsw.name != request["name"]:
             try:
                 frsw.name = request["name"]
+                response["name"] = frsw.name
             except DynamipsError as e:
                 self.send_custom_error(str(e))
                 return
+
         self.send_response(request)
 
     @IModule.route("dynamips.frsw.allocate_udp_port")
@@ -151,17 +160,14 @@ class FRSW(object):
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, FRSW_ALLOCATE_UDP_PORT_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        frsw_id = request["id"]
-        if frsw_id not in self._frame_relay_switches:
-            self.send_custom_error("Frame relay switch id {} doesn't exist".format(frsw_id))
+        # get the Frame relay switch instance
+        frsw = self.get_device_instance(request["id"], self._frame_relay_switches)
+        if not frsw:
             return
-        frsw = self._frame_relay_switches[frsw_id]
 
         try:
             # allocate a new UDP port
@@ -183,42 +189,39 @@ class FRSW(object):
         - port (port identifier)
         - port_id (port identifier)
         - mappings (VCs mapped to the port)
-        - nio (nio type, one of the following)
-            - "NIO_UDP"
+        - nio (one of the following)
+            - type "nio_udp"
                 - lport (local port)
                 - rhost (remote host)
                 - rport (remote port)
-            - "NIO_GenericEthernet"
+            - type "nio_generic_ethernet"
                 - ethernet_device (Ethernet device name e.g. eth0)
-            - "NIO_LinuxEthernet"
+            - type "nio_linux_ethernet"
                 - ethernet_device (Ethernet device name e.g. eth0)
-            - "NIO_TAP"
+            - type "nio_tap"
                 - tap_device (TAP device name e.g. tap0)
-            - "NIO_UNIX"
+            - type "nio_unix"
                 - local_file (path to UNIX socket file)
                 - remote_file (path to UNIX socket file)
-            - "NIO_VDE"
+            - type "nio_vde"
                 - control_file (path to VDE control file)
                 - local_file (path to VDE local file)
-            - "NIO_Null"
+            - type "nio_null"
 
         Response parameters:
-        - same as original request
+        - port_id (unique port identifier)
 
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, FRSW_ADD_NIO_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        frsw_id = request["id"]
-        if frsw_id not in self._frame_relay_switches:
-            self.send_custom_error("Frame relay switch id {} doesn't exist".format(frsw_id))
+        # get the Frame relay switch instance
+        frsw = self.get_device_instance(request["id"], self._frame_relay_switches)
+        if not frsw:
             return
-        frsw = self._frame_relay_switches[frsw_id]
 
         port = request["port"]
         mappings = request["mappings"]
@@ -246,8 +249,7 @@ class FRSW(object):
             self.send_custom_error(str(e))
             return
 
-        # for now send back the original request
-        self.send_response(request)
+        self.send_response({"port_id": request["port_id"]})
 
     @IModule.route("dynamips.frsw.delete_nio")
     def frsw_delete_nio(self, request):
@@ -259,24 +261,21 @@ class FRSW(object):
         - port (port identifier)
 
         Response parameters:
-        - same as original request
+        - True on success
 
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, FRSW_DELETE_NIO_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        frsw_id = request["id"]
-        if frsw_id not in self._frame_relay_switches:
-            self.send_custom_error("Frame relay switch id {} doesn't exist".format(frsw_id))
+        # get the Frame relay switch instance
+        frsw = self.get_device_instance(request["id"], self._frame_relay_switches)
+        if not frsw:
             return
-        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():
@@ -292,5 +291,4 @@ class FRSW(object):
             self.send_custom_error(str(e))
             return
 
-        # for now send back the original request
-        self.send_response(request)
+        self.send_response(True)

gns3server/modules/dynamips/backends/vm.py

@@ -49,6 +49,19 @@ from ..adapters.wic_1enet import WIC_1ENET
 from ..adapters.wic_1t import WIC_1T
 from ..adapters.wic_2t import WIC_2T
 
+from ..schemas.vm import VM_CREATE_SCHEMA
+from ..schemas.vm import VM_DELETE_SCHEMA
+from ..schemas.vm import VM_START_SCHEMA
+from ..schemas.vm import VM_STOP_SCHEMA
+from ..schemas.vm import VM_SUSPEND_SCHEMA
+from ..schemas.vm import VM_RELOAD_SCHEMA
+from ..schemas.vm import VM_UPDATE_SCHEMA
+from ..schemas.vm import VM_SAVE_CONFIG_SCHEMA
+from ..schemas.vm import VM_IDLEPCS_SCHEMA
+from ..schemas.vm import VM_ALLOCATE_UDP_PORT_SCHEMA
+from ..schemas.vm import VM_ADD_NIO_SCHEMA
+from ..schemas.vm import VM_DELETE_NIO_SCHEMA
+
 import logging
 log = logging.getLogger(__name__)
 
@@ -110,13 +123,10 @@ class VM(object):
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, VM_CREATE_SCHEMA):
             return
 
-        log.debug("received request {}".format(request))
-
-        #TODO: JSON schema validation
         name = None
         if "name" in request:
             name = request["name"]
@@ -130,6 +140,9 @@ class VM(object):
 
         try:
 
+            if platform not in PLATFORMS:
+                raise DynamipsError("Unknown router platform: {}".format(platform))
+
             if not self._hypervisor_manager:
                 self.start_hypervisor_manager()
 
@@ -197,22 +210,20 @@ class VM(object):
         - id (vm identifier)
 
         Response parameters:
-        - same as original request
+        - True on success
 
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, VM_DELETE_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
+        # get the router instance
         router_id = request["id"]
-        if router_id not in self._routers:
-            self.send_custom_error("IOS router id {} doesn't exist".format(router_id))
+        router = self.get_device_instance(router_id, self._routers)
+        if not router:
             return
-        router = self._routers[router_id]
 
         try:
             router.delete()
@@ -221,7 +232,8 @@ class VM(object):
         except DynamipsError as e:
             self.send_custom_error(str(e))
             return
-        self.send_response(request)
+
+        self.send_response(True)
 
     @IModule.route("dynamips.vm.start")
     def vm_start(self, request):
@@ -232,29 +244,26 @@ class VM(object):
         - id (vm identifier)
 
         Response parameters:
-        - same as original request
+        - True on success
 
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, VM_START_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        router_id = request["id"]
-        if router_id not in self._routers:
-            self.send_custom_error("IOS router id {} doesn't exist".format(router_id))
+        # get the router instance
+        router = self.get_device_instance(request["id"], self._routers)
+        if not router:
             return
-        router = self._routers[router_id]
 
         try:
             router.start()
         except DynamipsError as e:
             self.send_custom_error(str(e))
             return
-        self.send_response(request)
+        self.send_response(True)
 
     @IModule.route("dynamips.vm.stop")
     def vm_stop(self, request):
@@ -265,29 +274,27 @@ class VM(object):
         - id (vm identifier)
 
         Response parameters:
-        - same as original request
+        - True on success
 
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, VM_STOP_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        router_id = request["id"]
-        if router_id not in self._routers:
-            self.send_custom_error("IOS router id {} doesn't exist".format(router_id))
+        # get the router instance
+        router = self.get_device_instance(request["id"], self._routers)
+        if not router:
             return
-        router = self._routers[router_id]
 
         try:
             router.stop()
         except DynamipsError as e:
             self.send_custom_error(str(e))
             return
-        self.send_response(request)
+
+        self.send_response(True)
 
     @IModule.route("dynamips.vm.suspend")
     def vm_suspend(self, request):
@@ -298,29 +305,27 @@ class VM(object):
         - id (vm identifier)
 
         Response parameters:
-        - same as original request
+        - True on success
 
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, VM_SUSPEND_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        router_id = request["id"]
-        if router_id not in self._routers:
-            self.send_custom_error("IOS router id {} doesn't exist".format(router_id))
+        # get the router instance
+        router = self.get_device_instance(request["id"], self._routers)
+        if not router:
             return
-        router = self._routers[router_id]
 
         try:
             router.suspend()
         except DynamipsError as e:
             self.send_custom_error(str(e))
             return
-        self.send_response(request)
+
+        self.send_response(True)
 
     @IModule.route("dynamips.vm.reload")
     def vm_reload(self, request):
@@ -331,22 +336,20 @@ class VM(object):
         - id (vm identifier)
 
         Response parameters:
-        - same as original request
+        - True on success
 
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, VM_RELOAD_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        router_id = request["id"]
-        if router_id not in self._routers:
-            self.send_custom_error("IOS router id {} doesn't exist".format(router_id))
+        # get the router instance
+        router = self.get_device_instance(request["id"], self._routers)
+        if not router:
             return
-        router = self._routers[router_id]
+
         try:
             if router.get_status() != "inactive":
                 router.stop()
@@ -354,7 +357,8 @@ class VM(object):
         except DynamipsError as e:
             self.send_custom_error(str(e))
             return
-        self.send_response(request)
+
+        self.send_response(True)
 
     @IModule.route("dynamips.vm.update")
     def vm_update(self, request):
@@ -370,37 +374,35 @@ class VM(object):
         - private_config_base64 (private-config base64 encoded)
 
         Response parameters:
-        - same as original request
+        - updated settings
 
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, VM_UPDATE_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        router_id = request["id"]
-        if router_id not in self._routers:
-            self.send_custom_error("IOS router id {} doesn't exist".format(router_id))
+        # get the router instance
+        router = self.get_device_instance(request["id"], self._routers)
+        if not router:
             return
-        router = self._routers[router_id]
 
+        response = {}
         try:
             # a new startup-config has been pushed
             if "startup_config_base64" in request:
                 config_filename = "{}.cfg".format(router.name)
-                request["startup_config"] = self.save_base64config(request["startup_config_base64"], router, config_filename)
-            if "startup_config" in request:
-                router.set_config(request["startup_config"])
+                response["startup_config"] = self.save_base64config(request["startup_config_base64"], router, config_filename)
+            if "startup_config" in response:
+                router.set_config(response["startup_config"])
 
             # a new private-config has been pushed
             if "private_config_base64" in request:
                 config_filename = "{}-private.cfg".format(router.name)
-                request["private_config"] = self.save_base64config(request["private_config_base64"], router, config_filename)
-            if "private_config" in request:
-                router.set_config(router.startup_config, request["private_config"])
+                response["private_config"] = self.save_base64config(request["private_config_base64"], router, config_filename)
+            if "private_config" in response:
+                router.set_config(router.startup_config, response["private_config"])
 
         except DynamipsError as e:
             self.send_custom_error(str(e))
@@ -411,6 +413,7 @@ class VM(object):
             if hasattr(router, name) and getattr(router, name) != value:
                 try:
                     setattr(router, name, value)
+                    response[name] = value
                 except DynamipsError as e:
                     self.send_custom_error(str(e))
                     return
@@ -422,6 +425,7 @@ class VM(object):
                     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)
+                    response[name] = value
                 except DynamipsError as e:
                     self.send_custom_error(str(e))
                     return
@@ -430,6 +434,7 @@ class VM(object):
                 if router.slots[slot_id]:
                     try:
                         router.slot_remove_binding(slot_id)
+                        response[name] = value
                     except DynamipsError as e:
                         self.send_custom_error(str(e))
                         return
@@ -441,6 +446,7 @@ class VM(object):
                     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)
+                    response[name] = value
                 except DynamipsError as e:
                     self.send_custom_error(str(e))
                     return
@@ -449,6 +455,7 @@ class VM(object):
                 if router.slots[0].wics and router.slots[0].wics[wic_slot_id]:
                     try:
                         router.uninstall_wic(wic_slot_id)
+                        response[name] = value
                     except DynamipsError as e:
                         self.send_custom_error(str(e))
                         return
@@ -457,8 +464,7 @@ class VM(object):
         if self._hypervisor_manager.ghost_ios_support:
             self.set_ghost_ios(router)
 
-        # for now send back the original request
-        self.send_response(request)
+        self.send_response(response)
 
     @IModule.route("dynamips.vm.save_config")
     def vm_save_config(self, request):
@@ -469,17 +475,14 @@ class VM(object):
         - id (vm identifier)
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, VM_SAVE_CONFIG_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        router_id = request["id"]
-        if router_id not in self._routers:
-            self.send_custom_error("IOS router id {} doesn't exist".format(router_id))
+        # get the router instance
+        router = self.get_device_instance(request["id"], self._routers)
+        if not router:
             return
-        router = self._routers[router_id]
 
         try:
             if router.startup_config or router.private_config:
@@ -528,17 +531,14 @@ class VM(object):
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, VM_IDLEPCS_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        router_id = request["id"]
-        if router_id not in self._routers:
-            self.send_custom_error("IOS router id {} doesn't exist".format(router_id))
+        # get the router instance
+        router = self.get_device_instance(request["id"], self._routers)
+        if not router:
             return
-        router = self._routers[router_id]
 
         try:
             if "compute" in request and request["compute"] == False:
@@ -551,7 +551,7 @@ class VM(object):
             self.send_custom_error(str(e))
             return
 
-        response = {"id": router_id,
+        response = {"id": router.id,
                     "idlepcs": idlepcs}
         self.send_response(response)
 
@@ -571,17 +571,14 @@ class VM(object):
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, VM_ALLOCATE_UDP_PORT_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        router_id = request["id"]
-        if router_id not in self._routers:
-            self.send_custom_error("IOS router id {} doesn't exist".format(router_id))
+        # get the router instance
+        router = self.get_device_instance(request["id"], self._routers)
+        if not router:
             return
-        router = self._routers[router_id]
 
         try:
             # allocate a new UDP port
@@ -603,46 +600,42 @@ class VM(object):
         - slot (slot number)
         - port (port number)
         - port_id (unique port identifier)
-        - nio (nio type, one of the following)
-            - "NIO_UDP"
+        - nio (one of the following)
+            - type "nio_udp"
                 - lport (local port)
                 - rhost (remote host)
                 - rport (remote port)
-            - "NIO_GenericEthernet"
+            - type "nio_generic_ethernet"
                 - ethernet_device (Ethernet device name e.g. eth0)
-            - "NIO_LinuxEthernet"
+            - type "nio_linux_ethernet"
                 - ethernet_device (Ethernet device name e.g. eth0)
-            - "NIO_TAP"
+            - type "nio_tap"
                 - tap_device (TAP device name e.g. tap0)
-            - "NIO_UNIX"
+            - type "nio_unix"
                 - local_file (path to UNIX socket file)
                 - remote_file (path to UNIX socket file)
-            - "NIO_VDE"
+            - type "nio_vde"
                 - control_file (path to VDE control file)
                 - local_file (path to VDE local file)
-            - "NIO_Null"
+            - type "nio_null"
 
         Response parameters:
-        - same as original request
+        - port_id (unique port identifier)
 
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, VM_ADD_NIO_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        router_id = request["id"]
-        if router_id not in self._routers:
-            self.send_custom_error("IOS router id {} doesn't exist".format(router_id))
+        # get the router instance
+        router = self.get_device_instance(request["id"], self._routers)
+        if not router:
             return
-        router = self._routers[router_id]
 
         slot = request["slot"]
         port = request["port"]
-
         try:
             nio = self.create_nio(router, request)
             if not nio:
@@ -657,8 +650,7 @@ class VM(object):
             self.send_custom_error(str(e))
             return
 
-        # for now send back the original request
-        self.send_response(request)
+        self.send_response({"port_id": request["port_id"]})
 
     @IModule.route("dynamips.vm.delete_nio")
     def vm_delete_nio(self, request):
@@ -671,25 +663,22 @@ class VM(object):
         - port (port identifier)
 
         Response parameters:
-        - same as original request
+        - True on success
 
         :param request: JSON request
         """
 
-        if request == None:
-            self.send_param_error()
+        # validate the request
+        if not self.validate_request(request, VM_DELETE_NIO_SCHEMA):
             return
 
-        #TODO: JSON schema validation for the request
-        log.debug("received request {}".format(request))
-        router_id = request["id"]
-        router = self._routers[router_id]
-        if router_id not in self._routers:
-            self.send_custom_error("IOS router id {} doesn't exist".format(router_id))
+        # get the router instance
+        router = self.get_device_instance(request["id"], self._routers)
+        if not router:
             return
+
         slot = request["slot"]
         port = request["port"]
-
         try:
             nio = router.slot_remove_nio_binding(slot, port)
             nio.delete()
@@ -697,5 +686,4 @@ class VM(object):
             self.send_custom_error(str(e))
             return
 
-        # for now send back the original request
-        self.send_response(request)
+        self.send_response(True)