Added JSON schema validation for imported VM settings.

coriolis/api/v1/migrations.py

@@ -51,6 +51,10 @@ class MigrationController(api_wsgi.Controller):
             # TODO: use a decent exception
             raise exception.CoriolisException("Invalid connection info")
 
+        if not import_provider.validate_target_environment(
+                destination.get("target_environment", {})):
+            raise exception.CoriolisException("Invalid target environment")
+
         return origin, destination, migration["instances"]
 
     def create(self, req, body):

coriolis/constants.py

@@ -16,10 +16,14 @@ PROVIDER_TYPE_EXPORT = 2
 
 DISK_FORMAT_VMDK = 'vmdk'
 DISK_FORMAT_RAW = 'raw'
+DISK_FORMAT_QCOW = "qcow"
 DISK_FORMAT_QCOW2 = 'qcow2'
 DISK_FORMAT_VHD = 'vhd'
 DISK_FORMAT_VHDX = 'vhdx'
 
+FIRMWARE_TYPE_BIOS = 'BIOS'
+FIRMWARE_TYPE_EFI = 'EFI'
+
 HYPERVISOR_VMWARE = "vmware"
 HYPERVISOR_HYPERV = "hyperv"
 HYPERVISOR_QEMU = "qemu"

coriolis/providers/base.py

@@ -1,6 +1,7 @@
 import abc
 
 from coriolis import events
+from coriolis import schemas
 
 
 class BaseProvider(object):
@@ -9,17 +10,52 @@ class BaseProvider(object):
     def __init__(self, event_handler):
         self._event_manager = events.EventManager(event_handler)
 
+    @property
+    def connection_info_schema(self):
+        raise NotImplementedError("Missing connection info schema.")
+
     @abc.abstractmethod
     def validate_connection_info(self, connection_info):
-        pass
+        """ Checks the provided connection info and raises an exception
+        if it is invalid.
+        """
+        try:
+            schemas.validate_value(
+                connection_info, self.connection_info_schema)
+        except:
+            return False
+
+        return True
 
 
 class BaseImportProvider(BaseProvider):
     __metaclass__ = abc.ABCMeta
 
+    @property
+    def target_environment_schema(self):
+        raise NotImplementedError("Missing target environment schema.")
+
+    @abc.abstractmethod
+    def validate_target_environment(self, target_environment):
+        """ Checks the provided target environment info and raises an exception
+        if it is invalid.
+        """
+        try:
+            schemas.validate_value(
+                target_environment, self.target_environment_schema)
+        except:
+            return False
+
+        return True
+
+
     @abc.abstractmethod
     def import_instance(self, ctxt, connection_info, target_environment,
                         instance_name, export_info):
+        """ Imports the instance given by its name to the specified target
+        environment within the destination cloud based on the provided
+        connection and export info.
+        """
         pass
 
 
@@ -29,4 +65,7 @@ class BaseExportProvider(BaseProvider):
     @abc.abstractmethod
     def export_instance(self, ctxt, connection_info, instance_name,
                         export_path):
+        """ Exports the instance given by its name from the given source cloud
+        to the provided export directory path using the given connection info.
+        """
         pass

coriolis/providers/openstack/__init__.py

@@ -18,6 +18,7 @@ from coriolis import exception
 from coriolis import keystone
 from coriolis.osmorphing import manager as osmorphing_manager
 from coriolis.providers import base
+from coriolis import schemas
 from coriolis import utils
 
 opts = [
@@ -180,8 +181,12 @@ class _MigrationResources(object):
 
 
 class ImportProvider(base.BaseImportProvider):
-    def validate_connection_info(self, connection_info):
-        return True
+
+    connection_info_schema = schemas.get_schema(
+        __name__, schemas.PROVIDER_CONNECTION_INFO_SCHEMA_NAME)
+
+    target_environment_schema = schemas.get_schema(
+        __name__, schemas.PROVIDER_TARGET_ENVIRONMENT_SCHEMA_NAME)
 
     def _create_image(self, glance, name, disk_path, disk_format,
                       container_format, hypervisor_type):

coriolis/providers/openstack/schemas/connection_info_schema.json

@@ -0,0 +1,50 @@
+{
+  "$schema": "http://cloudbase.it/coriolis/schemas/openstack_connection#",
+  "type": "object",
+  "properties": {
+    "secret_ref": {
+      "type": "string"
+    },
+    "identity_api_version": {
+      "type": "integer"
+    },
+    "username": {
+      "type": "string"
+    },
+    "password": {
+      "type": "string"
+    },
+    "project_name": {
+      "type": "string"
+    },
+    "user_domain_name": {
+      "type": "string"
+    },
+    "project_domain_name": {
+      "type": "string"
+    },
+    "auth_url": {
+      "type": "string"
+    },
+    "allow_untrusted": {
+      "type": "boolean",
+      "default": false
+    }
+  },
+  "oneOf": [
+    {
+      "required": ["secret_ref"]
+    },
+    {
+      "required": [
+        "identity_api_version",
+        "username",
+        "password",
+        "project_name",
+        "user_domain_name",
+        "project_domain_name",
+        "auth_url"
+      ]
+    }
+  ]
+}

coriolis/providers/openstack/schemas/target_environment_schema.json

@@ -0,0 +1,50 @@
+{
+  "$schema": "http://cloudbase.it/coriolis/schemas/openstack_target_environment#",
+  "type": "object",
+  "properties": {
+    "secret_ref": {
+      "type": "string"
+    },
+    "network_map": {
+      "type": "object",
+      "properties": {
+        "VM Network Local": {
+          "type": "string"
+        },
+        "VM Network": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "VM Network Local",
+        "VM Network"
+      ]
+    },
+    "flavor_name": {
+      "type": "string"
+    },
+    "fip_pool_name": {
+      "type": "string"
+    },
+    "migr_fip_pool_name": {
+      "type": "string"
+    },
+    "keypair_name": {
+      "type": "string"
+    }
+  },
+  "oneOf": [
+    {
+      "required": ["secret_ref"]
+    },
+    {
+      "required": [
+        "network_map",
+        "flavor_name",
+        "fip_pool_name",
+        "migr_fip_pool_name",
+        "keypair_name"
+      ]
+    }
+  ]
+}

coriolis/providers/vmware_vsphere/__init__.py

@@ -14,6 +14,7 @@ from coriolis import constants
 from coriolis import exception
 from coriolis.providers import base
 from coriolis.providers.vmware_vsphere import guestid
+from coriolis import schemas
 from coriolis import utils
 
 vmware_vsphere_opts = [
@@ -29,8 +30,9 @@ LOG = logging.getLogger(__name__)
 
 
 class ExportProvider(base.BaseExportProvider):
-    def validate_connection_info(self, connection_info):
-        return True
+
+    connection_info_schema = schemas.get_schema(
+        __name__, schemas.PROVIDER_CONNECTION_INFO_SCHEMA_NAME)
 
     @utils.retry_on_error()
     def _convert_disk_type(self, disk_path, target_disk_path, target_type=0):
@@ -102,8 +104,11 @@ class ExportProvider(base.BaseExportProvider):
         vm = self._get_vm(si, instance_path)
 
         firmware_type_map = {
-            vim.vm.GuestOsDescriptor.FirmwareType.bios: 'BIOS',
-            vim.vm.GuestOsDescriptor.FirmwareType.efi: 'EFI'}
+            vim.vm.GuestOsDescriptor.FirmwareType.bios:
+                constants.FIRMWARE_TYPE_BIOS,
+            vim.vm.GuestOsDescriptor.FirmwareType.efi:
+                constants.FIRMWARE_TYPE_EFI
+        }
 
         vm_info = {
             'num_cpu': vm.config.hardware.numCPU,
@@ -161,8 +166,8 @@ class ExportProvider(base.BaseExportProvider):
         devices = [d for d in vm.config.hardware.device if
                    isinstance(d, vim.vm.device.VirtualDisk)]
         for device in devices:
-            disks.append({'size': device.capacityInBytes,
-                          'address': device.unitNumber,
+            disks.append({'size_bytes': device.capacityInBytes,
+                          'unit_number': device.unitNumber,
                           'id': device.key,
                           'controller_id': device.controllerKey})
 
@@ -170,15 +175,15 @@ class ExportProvider(base.BaseExportProvider):
         devices = [d for d in vm.config.hardware.device if
                    isinstance(d, vim.vm.device.VirtualCdrom)]
         for device in devices:
-            cdroms.append({'address': device.unitNumber, 'id': device.key,
+            cdroms.append({'unit_number': device.unitNumber, 'id': device.key,
                            'controller_id': device.controllerKey})
 
-        floppy = []
+        floppies = []
         devices = [d for d in vm.config.hardware.device if
                    isinstance(d, vim.vm.device.VirtualFloppy)]
         for device in devices:
-            floppy.append({'address': device.unitNumber, 'id': device.key,
-                           'controller_id': device.controllerKey})
+            floppies.append({'unit_number': device.unitNumber, 'id': device.key,
+                             'controller_id': device.controllerKey})
 
         nics = []
         devices = [d for d in vm.config.hardware.device if
@@ -215,7 +220,7 @@ class ExportProvider(base.BaseExportProvider):
             "controllers": disk_ctrls,
             "disks": disks,
             "cdroms": cdroms,
-            "floppy": floppy,
+            "floppies": floppies,
             "serial_ports": serial_ports
         }
         vm_info["boot_order"] = boot_order

coriolis/providers/vmware_vsphere/schemas/connection_info_schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "http://cloudbase.it/coriolis/schemas/vmware_vsphere_connection#",
+  "type": "object",
+  "properties": {
+    "secret_ref": {
+      "type": "string"
+    },
+    "host": {
+      "type": "string"
+    },
+    "port": {
+      "type": "integer"
+    },
+    "username": {
+      "type": "string"
+    },
+    "password": {
+      "type": "string"
+    },
+    "allow_untrusted": {
+      "type": "boolean",
+      "default": false
+    }
+  },
+  "oneOf": [
+    {
+      "required": ["secret_ref"]
+    },
+    {
+      "required": [
+        "host",
+        "port",
+        "username",
+        "password"
+      ]
+    }
+  ]
+}

coriolis/schemas.py

@@ -0,0 +1,54 @@
+""" Defines various schemas used for validation throughout the project. """
+
+import json
+
+import logging
+import jinja2
+import jsonschema
+
+
+LOG = logging.getLogger(__name__)
+
+
+PROVIDER_CONNECTION_INFO_SCHEMA_NAME = "connection_info_schema.json"
+
+PROVIDER_TARGET_ENVIRONMENT_SCHEMA_NAME = "target_environment_schema.json"
+
+
+def get_schema(package_name, schema_name, schemas_directory="schemas"):
+    """ Loads the schema with the given 'schema_name' using jinja2 template
+    loading from the provided 'package_name' under the given
+    'schemas_directory'.
+    """
+    template_env = jinja2.Environment(
+        loader=jinja2.PackageLoader(package_name, schemas_directory))
+
+    schema = json.loads(template_env.get_template(schema_name).render())
+
+    LOG.info("Succesfully loaded and parsed schema '%s' from '%s'.",
+             schema_name, package_name)
+    return schema
+
+
+def validate_value(val, schema):
+    """ Simple wrapper for jsonschema.validate for usability.
+
+    NOTE: silently passes empty schemas.
+    """
+    jsonschema.validate(val, schema)
+
+
+def validate_string(string, schema):
+    """ Attempts to validate the json value provided as a string against the
+    given JSON schema.
+
+    Runs silently on success or raises an exception otherwise.
+    Silently passes empty schemas.
+    """
+    jsonschema.validate(json.loads(string), schema)
+
+
+# Global schemas:
+CORIOLIS_VM_EXPORT_INFO_SCHEMA_NAME = "vm_export_info_schema.json"
+CORIOLIS_VM_EXPORT_INFO_SCHEMA = get_schema(
+    __name__, CORIOLIS_VM_EXPORT_INFO_SCHEMA_NAME)

coriolis/schemas/vm_export_info_schema.json

@@ -0,0 +1,251 @@
+{
+  "$schema": "http://cloudbase.it/coriolis/schemas/vm_export_info#",
+  "type": "object",
+  "properties": {
+    "num_cpu": {
+      "type": "integer",
+      "description": "Number of CPUs of the VM."
+    },
+    "num_cores_per_socket": {
+      "type": "integer",
+      "description": "Number of CPU cores per socket, if applicable."
+    },
+    "memory_mb": {
+      "type": "integer",
+      "description": "Memory of the VM in MegaBytes."
+    },
+    "name": {
+      "type": "string",
+      "description": "Human-readable name of th VM."
+    },
+    "id": {
+      "type": "string",
+      "description": "Unique identifier of the VM."
+    },
+    "dynamic_memory_enabled": {
+      "type": "boolean",
+      "description": "Indicates whether not the VM's physical memory was allocated dynamically."
+    },
+    "os_type": {
+      "type": "string",
+      "description": "The generic type of the operating system installed on the VM.",
+      "enum": ["bsd", "linux", "osx", "solaris", "windows"]
+    },
+    "firmware_type": {
+      "type": "string",
+      "description": "The type of firmware of the VM.",
+      "enum": ["BIOS", "EFI"]
+    },
+    "nested_virtualization": {
+      "type": "boolean",
+      "description": "Indicates whether or not nested hardware accelerated virtualization is possible on the VM."
+    },
+    "guest_id": {
+      "type": "string",
+      "description": "Extra IS field for added categorisation."
+    },
+    "devices": {
+      "type": "object",
+      "description": "Contains information about all of the VM's devices.",
+      "properties": {
+        "disks": {
+          "type": "array",
+          "description": "List of all disks attached to the VM.",
+          "items": {
+            "type": "object",
+            "properties": {
+              "id": {
+                "$ref": "#/definitions/numberOrString"
+              },
+              "format": {
+                "type": "string",
+                "enum": ["vmdk", "raw", "qcow", "qcow2", "vhd", "vhdx"]
+              },
+              "unit_number": {
+                "$ref": "#/definitions/numberOrString"
+              },
+              "size_bytes": {
+                "type": "integer"
+              },
+              "path": {
+                "type": "string"
+              },
+              "controller_id": {
+                "$ref": "#/definitions/numberOrString"
+              }
+            },
+            "required": [
+              "format",
+              "size_bytes",
+              "path"
+            ]
+          }
+        },
+        "cdroms": {
+          "type": "array",
+          "description": "List of all CDROM devices attached to the VM.",
+          "items": {
+            "type": "object",
+            "properties": {
+              "id": {
+                "$ref": "#/definitions/numberOrString"
+              },
+              "unit_number": {
+                "$ref": "#/definitions/numberOrString"
+              },
+              "controller_id": {
+                "$ref": "#/definitions/numberOrString"
+              }
+            },
+            "required": [
+              "unit_number"
+            ]
+          }
+        },
+        "nics": {
+          "type": "array",
+          "description": "List of the network interface devices attached to the VM",
+          "items": {
+            "type": "object",
+            "properties": {
+              "network_name": {
+                "type": "string"
+              },
+              "name": {
+                "type": "string"
+              },
+              "id": {
+                "$ref": "#/definitions/numberOrString"
+              },
+              "mac_address": {
+                "$ref": "#/definitions/nullableString"
+              }
+            },
+            "required": [
+              "network_name",
+              "mac_address"
+            ]
+          }
+        },
+        "serial_ports": {
+          "type": "array",
+          "description": "List of additional serial ports attached to the VM.",
+          "items": {
+            "type": "object",
+            "properties": {
+              "id": {
+                "$ref": "#/definitions/numberOrString"
+              }
+            }
+          },
+          "required": [
+            "id"
+          ]
+        },
+        "floppies": {
+          "type": "array",
+          "description": "List of all floppy devices attached to the VM.",
+          "items": {
+            "type": "object",
+            "properties": {
+              "id": {
+                "$ref": "#/definitions/numberOrString"
+              },
+              "unit_number": {
+                "$ref": "#/definitions/numberOrString"
+              },
+              "controller_id": {
+                "$ref": "#/definitions/numberOrString"
+              }
+            },
+            "required": [
+              "unit_number"
+            ]
+          }
+        },
+        "controllers": {
+          "type": "array",
+          "description": "List of all disk controllers available to the VM.",
+          "items": {
+            "type": "object",
+            "properties": {
+              "type": {
+                "type": "string"
+              },
+              "bus_number": {
+                "$ref": "#/definitions/numberOrString"
+              },
+              "id": {
+                "$ref": "#/definitions/numberOrString"
+              }
+            },
+            "required": [
+              "type",
+              "bus_number",
+              "id"
+            ]
+          }
+        }
+      },
+      "required": [
+        "disks",
+        "cdroms",
+        "nics",
+        "serial_ports",
+        "floppies",
+        "controllers"
+      ]
+    },
+    "boot_order": {
+      "type": "array",
+      "description": "List specifying the boot order of the VM.",
+      "items": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string"
+          },
+          "id": {
+            "$ref": "#/definitions/numberOrString"
+          }
+        },
+        "required": [
+          "type",
+          "id"
+        ]
+      }
+    }
+  },
+  "required": [
+    "id",
+    "name",
+    "num_cpu",
+    "memory_mb",
+    "os_type",
+    "nested_virtualization",
+    "devices"
+  ],
+  "definitions": {
+    "numberOrString": {
+      "oneOf": [{
+        "type": "number"
+      }, {
+        "type": "string"
+      }]
+    },
+    "nullableNumber": {
+      "oneOf": [{
+        "type": "number"
+      }, {
+        "type": "null"
+      }]
+    },
+    "nullableString": {
+      "oneOf": [{
+        "type": "string"
+      }, {
+        "type": "null"
+      }]
+    }
+  }
+}

coriolis/schemas_exceptions.py

@@ -0,0 +1,32 @@
+""" Defines a set of exceptions possible during schema loading/validation. """
+
+import json
+
+import jinja2
+import jsonschema
+
+from coriolis import exception
+
+
+class CoriolisSchemaException(exception.CoriolisException):
+    """ Base class for all coriolis schema handling exceptions. """
+    message = "Exception occured during schema validation: %(msg)s."
+
+class CoriolisSchemaValidationError(
+        CoriolisSchemaException, jsonschema.ValidationError):
+    """ Raised when a schema validation has failed. """
+    message = "Failed to validate JSON schema: %(msg)s."
+
+
+class CoriolisSchemaParsingError(
+        CoriolisSchemaException, ValueError):
+    """ Raised when decoding of either the JSON schema or the JSON value being
+    validated occurs.
+    """
+    message = "Failed to parse JSON for schema validation: %(msg)s."
+
+
+class CoriolisSchemaLoadingException(
+        CoriolisSchemaException, jinja2.TemplateNotFound):
+    """ Raised when schema files are not found. """
+    message = "Failed to load schema: %(msg)s."

coriolis/worker/rpc/server.py

@@ -5,15 +5,16 @@ import queue
 import shutil
 import sys
 
+import psutil
 from oslo_config import cfg
 from oslo_log import log as logging
-import psutil
 
 from coriolis.conductor.rpc import client as rpc_conductor_client
 from coriolis import constants
 from coriolis import events
 from coriolis import exception
 from coriolis.providers import factory
+from coriolis import schemas
 from coriolis import secrets
 from coriolis import utils
 
@@ -208,6 +209,10 @@ def _task_process(ctxt, task_id, task_type, origin, destination, instance,
             result = provider.export_instance(ctxt, connection_info, instance,
                                               export_path)
             result[TMP_DIRS_KEY] = [export_path]
+
+            # validate the outputted VM info:
+            schemas.validate_value(
+                result, schemas.CORIOLIS_VM_EXPORT_INFO_SCHEMA)
         else:
             result = provider.import_instance(ctxt, connection_info,
                                               target_environment, instance,

requirements.txt

@@ -1,6 +1,7 @@
 eventlet
 keystoneauth1
 keystonemiddleware
+jsonschema
 PyMySQL
 oslo.concurrency
 oslo.config