From db558ec91f62925bb194dc737f71adcf2c3fe733 Mon Sep 17 00:00:00 2001
From: "Joshua M. Boniface" <joshua@boniface.me>
Date: Mon, 17 Feb 2020 22:52:49 -0500
Subject: [PATCH] Complete implementation of OVA handling

Add functions for uploading, listing, and removing OVA images to the API
and CLI interfaces. Includes improved parsing of the OVF and creation of
a system_template and profile for each OVA.

Also modifies some behaviour around profiles, making most components
option at creation to support both profile types (and incomplete
profiles generally).

Implementation part 2/3 - remaining: OVA VM creation

References #71
---
 api-daemon/pvcapid/flaskapi.py    | 382 +++++++++++++++++-------
 api-daemon/pvcapid/ova-tmp.py     |  46 +++
 api-daemon/pvcapid/ova.py         | 473 +++++++++++++++++++-----------
 api-daemon/pvcapid/provisioner.py |  29 +-
 client-cli/cli_lib/provisioner.py | 186 +++++++++++-
 client-cli/pvc.py                 | 117 +++++++-
 docs/manuals/swagger.json         | 242 ++++++++++++++-
 7 files changed, 1165 insertions(+), 310 deletions(-)
 create mode 100644 api-daemon/pvcapid/ova-tmp.py

diff --git a/api-daemon/pvcapid/flaskapi.py b/api-daemon/pvcapid/flaskapi.py
index 9e97afb0..44afd2d7 100755
--- a/api-daemon/pvcapid/flaskapi.py
+++ b/api-daemon/pvcapid/flaskapi.py
@@ -5193,6 +5193,228 @@ class API_Provisioner_Script_Element(Resource):
         )
 api.add_resource(API_Provisioner_Script_Element, '/provisioner/script/<script>')
 
+# /provisioner/profile
+class API_Provisioner_OVA_Root(Resource):
+    @RequestParser([
+        { 'name': 'limit' }
+    ])
+    @Authenticator
+    def get(self, reqargs):
+        """
+        Return a list of OVA sources
+        ---
+        tags:
+          - provisioner
+        definitions:
+          - schema:
+              type: object
+              id: ova
+              properties:
+                id:
+                  type: integer
+                  description: Internal provisioner OVA ID
+                name:
+                  type: string
+                  description: OVA name
+                volumes:
+                  type: list
+                  items:
+                    type: object
+                    id: ova_volume
+                    properties:
+                      disk_id:
+                        type: string
+                        description: Disk identifier
+                      disk_size_gb:
+                        type: string
+                        description: Disk size in GB
+                      pool:
+                        type: string
+                        description: Pool containing the OVA volume
+                      volume_name:
+                        type: string
+                        description: Storage volume containing the OVA image
+                      volume_format:
+                        type: string
+                        description: OVA image format
+        parameters:
+          - in: query
+            name: limit
+            type: string
+            required: false
+            description: An OVA name search limit; fuzzy by default, use ^/$ to force exact matches
+        responses:
+          200:
+            description: OK
+            schema:
+              type: list
+              items:
+                $ref: '#/definitions/ova'
+        """
+        return api_ova.list_ova(
+            reqargs.get('limit', None)
+        )
+
+    @RequestParser([
+        { 'name': 'pool', 'required': True, 'helpmsg': "A storage pool must be specified" },
+        { 'name': 'name', 'required': True, 'helpmsg': "A VM name must be specified" },
+        { 'name': 'ova_size', 'required': True, 'helpmsg': "An OVA size must be specified" },
+    ])
+    @Authenticator
+    def post(self, reqargs):
+        """
+        Upload an OVA image to the cluster
+
+        The API client is responsible for determining and setting the ova_size value, as this value cannot be determined dynamically before the upload proceeds.
+        ---
+        tags:
+          - provisioner
+        parameters:
+          - in: query
+            name: pool
+            type: string
+            required: true
+            description: Storage pool name
+          - in: query
+            name: name
+            type: string
+            required: true
+            description: OVA name on the cluster (usually identical to the OVA file name)
+          - in: query
+            name: ova_size
+            type: string
+            required: true
+            description: Size of the OVA file in bytes
+        responses:
+          200:
+            description: OK
+            schema:
+              type: object
+              id: Message
+          400:
+            description: Bad request
+            schema:
+              type: object
+              id: Message
+        """
+        from flask_restful import reqparse
+        from werkzeug.datastructures import FileStorage
+        parser = reqparse.RequestParser()
+        parser.add_argument('file', type=FileStorage, location='files')
+        data = parser.parse_args()
+        ova_data = data.get('file', None)
+        if not ova_data:
+            return {'message':'An OVA file contents must be specified'}, 400
+
+        return api_ova.upload_ova(
+            ova_data,
+            reqargs.get('pool', None),
+            reqargs.get('name', None),
+            reqargs.get('ova_size', None),
+        )
+api.add_resource(API_Provisioner_OVA_Root, '/provisioner/ova')
+
+# /provisioner/ova/<ova>
+class API_Provisioner_OVA_Element(Resource):
+    @Authenticator
+    def get(self, ova):
+        """
+        Return information about OVA image {ova}
+        ---
+        tags:
+          - provisioner
+        responses:
+          200:
+            description: OK
+            schema:
+              $ref: '#/definitions/ova'
+          404:
+            description: Not found
+            schema:
+              type: object
+              id: Message
+        """
+        return api_ova.list_ova(
+            ova,
+            is_fuzzy=False
+        )
+
+    @RequestParser([
+        { 'name': 'pool', 'required': True, 'helpmsg': "A storage pool must be specified" },
+        { 'name': 'ova_size', 'required': True, 'helpmsg': "An OVA size must be specified" },
+    ])
+    @Authenticator
+    def post(self, ova, reqargs):
+        """
+        Upload an OVA image to the cluster
+
+        The API client is responsible for determining and setting the ova_size value, as this value cannot be determined dynamically before the upload proceeds.
+        ---
+        tags:
+          - provisioner
+        parameters:
+          - in: query
+            name: pool
+            type: string
+            required: true
+            description: Storage pool name
+          - in: query
+            name: ova_size
+            type: string
+            required: true
+            description: Size of the OVA file in bytes
+        responses:
+          200:
+            description: OK
+            schema:
+              type: object
+              id: Message
+          400:
+            description: Bad request
+            schema:
+              type: object
+              id: Message
+        """
+        from flask_restful import reqparse
+        from werkzeug.datastructures import FileStorage
+        parser = reqparse.RequestParser()
+        parser.add_argument('file', type=FileStorage, location='files')
+        data = parser.parse_args()
+        ova_data = data.get('file', None)
+        if not ova_data:
+            return {'message':'An OVA file contents must be specified'}, 400
+
+        return api_ova.upload_ova(
+            ova_data,
+            reqargs.get('pool', None),
+            ova,
+            reqargs.get('ova_size', None),
+        )
+
+    @Authenticator
+    def delete(self, ova):
+        """
+        Remove ova {ova}
+        ---
+        tags:
+          - provisioner
+        responses:
+          200:
+            description: OK
+            schema:
+              type: object
+              id: Message
+          404:
+            description: Not found
+            schema:
+              type: object
+              id: Message
+        """
+        return api_ova.delete_ova(
+            ova
+        )
+api.add_resource(API_Provisioner_OVA_Element, '/provisioner/ova/<ova>')
+
 # /provisioner/profile
 class API_Provisioner_Profile_Root(Resource):
     @RequestParser([
@@ -5256,11 +5478,13 @@ class API_Provisioner_Profile_Root(Resource):
 
     @RequestParser([
         { 'name': 'name', 'required': True, 'helpmsg': "A profile name must be specified" },
-        { 'name': 'system_template', 'required': True, 'helpmsg': "A system template name must be specified" },
-        { 'name': 'network_template', 'required': True, 'helpmsg': "A network template name must be specified" },
-        { 'name': 'storage_template', 'required': True, 'helpmsg': "A storage template name must be specified" },
-        { 'name': 'userdata', 'required': True, 'helpmsg': "A userdata document name must be specified (use 'empty' if no template is desired)" },
-        { 'name': 'script', 'required': True, 'helpmsg': "A system name must be specified" },
+        { 'name': 'profile_type', 'required': True, 'helpmsg': "A profile type must be specified" },
+        { 'name': 'system_template' },
+        { 'name': 'network_template' },
+        { 'name': 'storage_template' },
+        { 'name': 'userdata' },
+        { 'name': 'script' },
+        { 'name': 'ova' },
         { 'name': 'arg', 'action': 'append' }
     ])
     @Authenticator
@@ -5277,30 +5501,43 @@ class API_Provisioner_Profile_Root(Resource):
             required: true
             description: Profile name
           - in: query
-            name: script
+            name: profile_type
             type: string
             required: true
+            description: Profile type
+            enum:
+              - provisioner
+              - ova
+          - in: query
+            name: script
+            type: string
+            required: false
             description: Script name
           - in: query
             name: system_template
             type: string
-            required: true
+            required: false
             description: System template name
           - in: query
             name: network_template
             type: string
-            required: true
+            required: false
             description: Network template name
           - in: query
             name: storage_template
             type: string
-            required: true
+            required: false
             description: Storage template name
           - in: query
             name: userdata
             type: string
-            required: true
+            required: false
             description: Userdata template name
+          - in: query
+            name: ova
+            type: string
+            required: false
+            description: OVA image source
           - in: query
             name: arg
             type: string
@@ -5319,11 +5556,13 @@ class API_Provisioner_Profile_Root(Resource):
         """
         return api_provisioner.create_profile(
             reqargs.get('name', None),
+            reqargs.get('profile_type', None),
             reqargs.get('system_template', None),
             reqargs.get('network_template', None),
             reqargs.get('storage_template', None),
             reqargs.get('userdata', None),
             reqargs.get('script', None),
+            reqargs.get('ova', None),
             reqargs.get('arg', [])
         )
 api.add_resource(API_Provisioner_Profile_Root, '/provisioner/profile')
@@ -5354,11 +5593,13 @@ class API_Provisioner_Profile_Element(Resource):
         )
 
     @RequestParser([
-        { 'name': 'system_template', 'required': True, 'helpmsg': "A system template name must be specified" },
-        { 'name': 'network_template', 'required': True, 'helpmsg': "A network template name must be specified" },
-        { 'name': 'storage_template', 'required': True, 'helpmsg': "A storage template name must be specified" },
-        { 'name': 'userdata', 'required': True, 'helpmsg': "A userdata document name must be specified (use 'empty' if no template is desired)" },
-        { 'name': 'script', 'required': True, 'helpmsg': "A system name must be specified" },
+        { 'name': 'profile_type', 'required': True, 'helpmsg': "A profile type must be specified" },
+        { 'name': 'system_template' },
+        { 'name': 'network_template' },
+        { 'name': 'storage_template' },
+        { 'name': 'userdata' },
+        { 'name': 'script' },
+        { 'name': 'ova' },
         { 'name': 'arg', 'action': 'append' }
     ])
     @Authenticator
@@ -5369,6 +5610,14 @@ class API_Provisioner_Profile_Element(Resource):
         tags:
           - provisioner
         parameters:
+          - in: query
+            name: profile_type
+            type: string
+            required: true
+            description: Profile type
+            enum:
+              - provisioner
+              - ova
           - in: query
             name: script
             type: string
@@ -5394,6 +5643,11 @@ class API_Provisioner_Profile_Element(Resource):
             type: string
             required: true
             description: Userdata template name
+          - in: query
+            name: ova
+            type: string
+            required: false
+            description: OVA image source
           - in: query
             name: arg
             type: string
@@ -5412,11 +5666,13 @@ class API_Provisioner_Profile_Element(Resource):
         """
         return api_provisioner.create_profile(
             profile,
+            reqargs.get('profile_type', None),
             reqargs.get('system_template', None),
             reqargs.get('network_template', None),
             reqargs.get('storage_template', None),
             reqargs.get('userdata', None),
             reqargs.get('script', None),
+            reqargs.get('ova', None),
             reqargs.get('arg', [])
         )
 
@@ -5479,12 +5735,14 @@ class API_Provisioner_Profile_Element(Resource):
         """
         return api_provisioner.modify_profile(
             profile,
+            None, # Can't modify the profile type
             reqargs.get('system_template', None),
             reqargs.get('network_template', None),
             reqargs.get('storage_template', None),
             reqargs.get('userdata', None),
             reqargs.get('script', None),
-            reqargs.get('arg', [])
+            None, # Can't modify the OVA
+            reqargs.get('arg', []),
         )
 
     @Authenticator
@@ -5587,98 +5845,6 @@ class API_Provisioner_Create_Root(Resource):
         return { "task_id": task.id }, 202, { 'Location': Api.url_for(api, API_Provisioner_Status_Element, task_id=task.id) }
 api.add_resource(API_Provisioner_Create_Root, '/provisioner/create')
 
-# /provisioner/upload
-class API_Provisioner_Upload(Resource):
-    @RequestParser([
-        { 'name': 'ova_size', 'required': True, 'helpmsg': "An OVA size must be specified" },
-        { 'name': 'pool', 'required': True, 'helpmsg': "A storage pool must be specified" },
-        { 'name': 'name', 'required': True, 'helpmsg': "A VM name must be specified" },
-        { 'name': 'define_vm' },
-        { 'name': 'start_vm' }
-    ])
-    @Authenticator
-    def post(self, reqargs):
-        """
-        Upload an OVA image to a new virtual machine
-
-        The API client is responsible for determining and setting the ova_size value, as this value cannot be determined dynamically before the upload proceeds.
-
-        Even if define_vm is false, the name will be used to name the resulting disk volumes as it would with a normally-provisioned VM.
-
-        The resulting VM, even if defined, will not have an attached provisioner profile.
-        ---
-        tags:
-          - provisioner
-        parameters:
-          - in: query
-            name: ova_size
-            type: string
-            required: true
-            description: Size of the OVA file in bytes
-          - in: query
-            name: pool
-            type: string
-            required: true
-            description: Storage pool name
-          - in: query
-            name: name
-            type: string
-            required: true
-            description: Virtual machine name
-          - in: query
-            name: define_vm
-            type: boolean
-            required: false
-            description: Whether to define the VM on the cluster during provisioning
-          - in: query
-            name: start_vm
-            type: boolean
-            required: false
-            description: Whether to start the VM after provisioning
-        responses:
-          200:
-            description: OK
-            schema:
-              type: object
-              properties:
-                task_id:
-                  type: string
-                  description: Task ID for the provisioner Celery worker
-          400:
-            description: Bad request
-            schema:
-              type: object
-              id: Message
-        """
-        from flask_restful import reqparse
-        from werkzeug.datastructures import FileStorage
-        parser = reqparse.RequestParser()
-        parser.add_argument('file', type=FileStorage, location='files')
-        data = parser.parse_args()
-        ova_data = data.get('file', None)
-        if not ova_data:
-            return {'message':'An OVA file contents must be specified'}, 400
-
-        if bool(strtobool(reqargs.get('define_vm', 'true'))):
-            define_vm = True
-        else:
-            define_vm = False
-
-        if bool(strtobool(reqargs.get('start_vm', 'true'))):
-            start_vm = True
-        else:
-            start_vm = False
-
-        return api_ova.upload_ova(
-            ova_data,
-            reqargs.get('ova_size', None),
-            reqargs.get('pool', None),
-            reqargs.get('name', None),
-            define_vm,
-            start_vm
-        )
-api.add_resource(API_Provisioner_Upload, '/provisioner/upload')
-
 # /provisioner/status
 class API_Provisioner_Status_Root(Resource):
     @Authenticator
diff --git a/api-daemon/pvcapid/ova-tmp.py b/api-daemon/pvcapid/ova-tmp.py
new file mode 100644
index 00000000..8f50a68f
--- /dev/null
+++ b/api-daemon/pvcapid/ova-tmp.py
@@ -0,0 +1,46 @@
+
+#
+# TEMP
+#
+def tempstuff():
+    # Verify that the cluster has enough space to store all OVA disk volumes
+    total_size_bytes = 0
+    for disk in disk_map:
+        # Normalize the dev size to MB
+        # The function always return XXXXB, so strip off the B and convert to an integer
+        dev_size_bytes = int(pvc_ceph.format_bytes_fromhuman(disk.get('capacity', 0))[:-1])
+        ova_size_bytes = int(pvc_ceph.format_bytes_fromhuman(ova_size)[:-1])
+        # Get the actual image size
+        total_size_bytes += dev_size_bytes
+        # Add on the OVA size to account for the VMDK
+        total_size_bytes += ova_size_bytes
+
+    zk_conn = pvc_common.startZKConnection(config['coordinators'])
+    pool_information = pvc_ceph.getPoolInformation(zk_conn, pool)
+    pvc_common.stopZKConnection(zk_conn)
+    pool_free_space_bytes = int(pool_information['stats']['free_bytes'])
+    if total_size_bytes >= pool_free_space_bytes:
+        output = {
+            'message': "ERROR: The cluster does not have enough free space ({}) to store the VM ({}).".format(
+                pvc_ceph.format_bytes_tohuman(pool_free_space_bytes),
+                pvc_ceph.format_bytes_tohuman(total_size_bytes)
+            )
+        }
+        retcode = 400
+        cleanup_ova_maps_and_volumes()
+        return output, retcode
+
+        # Convert from the temporary to destination format on the blockdevs
+        retcode, stdout, stderr = pvc_common.run_os_command(
+            'qemu-img convert -C -f {} -O raw {} {}'.format(img_type, temp_blockdev, dest_blockdev)
+        )
+        if retcode:
+            output = {
+                'message': "ERROR: Failed to convert image '{}' format from '{}' to 'raw': {}".format(disk.get('src'), img_type, stderr)
+            }
+            retcode = 400
+            cleanup_img_maps_and_volumes()
+            cleanup_ova_maps_and_volumes()
+            return output, retcode
+
+
diff --git a/api-daemon/pvcapid/ova.py b/api-daemon/pvcapid/ova.py
index 28df5a4e..0ae68170 100755
--- a/api-daemon/pvcapid/ova.py
+++ b/api-daemon/pvcapid/ova.py
@@ -42,47 +42,167 @@ import daemon_lib.network as pvc_network
 import daemon_lib.ceph as pvc_ceph
 
 import pvcapid.libvirt_schema as libvirt_schema
+import pvcapid.provisioner as provisioner
 
 #
-# OVA upload function
+# Common functions
 #
-def upload_ova(ova_data, ova_size, pool, name, define_vm, start_vm):
-    # Upload flow is as follows:
-    # 1. Create temporary volume of ova_size
-    # 2. Map the temporary volume for reading
-    # 3. Write OVA upload file to temporary volume
-    # 4. Read tar from temporary volume, extract OVF
-    # 5. Parse OVF, obtain disk list and VM details
-    # 6. Extract and "upload" via API each disk image to Ceph
-    # 7. Unmap and remove the temporary volume
-    # 8. Define VM (if applicable)
-    # 9. Start VM (if applicable)
-    ###########################################################
+
+# Database connections
+def open_database(config):
+    conn = psycopg2.connect(
+        host=config['database_host'],
+        port=config['database_port'],
+        dbname=config['database_name'],
+        user=config['database_user'],
+        password=config['database_password']
+    )
+    cur = conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
+    return conn, cur
+
+def close_database(conn, cur, failed=False):
+    if not failed:
+        conn.commit()
+    cur.close()
+    conn.close()
+
+#
+# OVA functions
+#
+def list_ova(limit, is_fuzzy=True):
+    if limit:
+        if is_fuzzy:
+            # Handle fuzzy vs. non-fuzzy limits
+            if not re.match('\^.*', limit):
+                limit = '%' + limit
+            else:
+                limit = limit[1:]
+            if not re.match('.*\$', limit):
+                limit = limit + '%'
+            else:
+                limit = limit[:-1]
+
+        query = "SELECT id, name FROM {} WHERE name LIKE %s;".format('ova')
+        args = (limit, )
+    else:
+        query = "SELECT id, name FROM {};".format('ova')
+        args = ()
+
+    conn, cur = open_database(config)
+    cur.execute(query, args)
+    data = cur.fetchall()
+    close_database(conn, cur)
+
+    ova_data = list()
+
+    for ova in data:
+        ova_id = ova.get('id')
+        ova_name = ova.get('name')
+
+        query = "SELECT pool, volume_name, volume_format, disk_id, disk_size_gb FROM {} WHERE ova = %s;".format('ova_volume')
+        args = (ova_id,)
+        conn, cur = open_database(config)
+        cur.execute(query, args)
+        volumes = cur.fetchall()
+        close_database(conn, cur)
+
+        ova_data.append({'id': ova_id, 'name': ova_name, 'volumes': volumes})
+
+    if ova_data:
+        return ova_data, 200
+    else:
+        return {'message': 'No OVAs found'}, 404
+
+def delete_ova(name):
+    ova_data, retcode = list_ova(name, is_fuzzy=False)
+    if retcode != 200:
+        retmsg = { 'message': 'The OVA "{}" does not exist'.format(name) }
+        retcode = 400
+        return retmsg, retcode
+
+    conn, cur = open_database(config)
+    ova_id = ova_data[0].get('id')
+    try:
+        # Get the list of volumes for this OVA
+        query = "SELECT pool, volume_name FROM ova_volume WHERE ova = %s;"
+        args = (ova_id,)
+        cur.execute(query, args)
+        volumes = cur.fetchall()
+
+        # Remove each volume for this OVA
+        zk_conn = pvc_common.startZKConnection(config['coordinators'])
+        for volume in volumes:
+            pvc_ceph.remove_volume(zk_conn, volume.get('pool'), volume.get('volume_name'))
+
+        # Delete the volume entries from the database
+        query = "DELETE FROM ova_volume WHERE ova = %s;"
+        args = (ova_id,)
+        cur.execute(query, args)
+
+        # Delete the profile entries from the database
+        query = "DELETE FROM profile WHERE ova = %s;"
+        args = (ova_id,)
+        cur.execute(query, args)
+
+        # Delete the system_template entries from the database
+        query = "DELETE FROM system_template WHERE ova = %s;"
+        args = (ova_id,)
+        cur.execute(query, args)
+
+        # Delete the OVA entry from the database
+        query = "DELETE FROM ova WHERE id = %s;"
+        args = (ova_id,)
+        cur.execute(query, args)
+
+        retmsg = { "message": 'Removed OVA image "{}"'.format(name) }
+        retcode = 200
+    except Exception as e:
+        retmsg = { 'message': 'Failed to remove OVA "{}": {}'.format(name, e) }
+        retcode = 400
+    close_database(conn, cur)
+    return retmsg, retcode
+
+def upload_ova(ova_data, pool, name, ova_size):
+    ova_archive = None
 
     # Cleanup function
     def cleanup_ova_maps_and_volumes():
         # Close the OVA archive
-        ova_archive.close()
+        if ova_archive:
+            ova_archive.close()
         zk_conn = pvc_common.startZKConnection(config['coordinators'])
         # Unmap the OVA temporary blockdev
-        retflag, retdata = pvc_ceph.unmap_volume(zk_conn, pool, "{}_ova".format(name))
+        retflag, retdata = pvc_ceph.unmap_volume(zk_conn, pool, "ova_{}".format(name))
         # Remove the OVA temporary blockdev
-        retflag, retdata = pvc_ceph.remove_volume(zk_conn, pool, "{}_ova".format(name))
+        retflag, retdata = pvc_ceph.remove_volume(zk_conn, pool, "ova_{}".format(name))
         pvc_common.stopZKConnection(zk_conn)
 
     # Normalize the OVA size to MB
-    print("Normalize the OVA size to MB")
     # The function always return XXXXB, so strip off the B and convert to an integer
     ova_size_bytes = int(pvc_ceph.format_bytes_fromhuman(ova_size)[:-1])
     # Put the size into KB which rbd --size can understand
     ova_size_kb = math.ceil(ova_size_bytes / 1024)
     ova_size = "{}K".format(ova_size_kb)
 
-    # Create a temporary OVA blockdev
-    print("Create a temporary OVA blockdev")
+    # Verify that the cluster has enough space to store the OVA volumes (2x OVA size, temporarily, 1x permanently)
     zk_conn = pvc_common.startZKConnection(config['coordinators'])
-    print(ova_size)
-    retflag, retdata = pvc_ceph.add_volume(zk_conn, pool, "{}_ova".format(name), ova_size)
+    pool_information = pvc_ceph.getPoolInformation(zk_conn, pool)
+    pvc_common.stopZKConnection(zk_conn)
+    pool_free_space_bytes = int(pool_information['stats']['free_bytes'])
+    if ova_size_bytes * 2 >= pool_free_space_bytes:
+        output = {
+            'message': "ERROR: The cluster does not have enough free space ({}) to store the OVA volume ({}).".format(
+                pvc_ceph.format_bytes_tohuman(pool_free_space_bytes),
+                pvc_ceph.format_bytes_tohuman(ova_size_bytes)
+            )
+        }
+        retcode = 400
+        cleanup_ova_maps_and_volumes()
+        return output, retcode
+
+    # Create a temporary OVA blockdev
+    zk_conn = pvc_common.startZKConnection(config['coordinators'])
+    retflag, retdata = pvc_ceph.add_volume(zk_conn, pool, "ova_{}".format(name), ova_size)
     pvc_common.stopZKConnection(zk_conn)
     if not retflag:
         output = {
@@ -93,9 +213,8 @@ def upload_ova(ova_data, ova_size, pool, name, define_vm, start_vm):
         return output, retcode
 
     # Map the temporary OVA blockdev
-    print("Map the temporary OVA blockdev")
     zk_conn = pvc_common.startZKConnection(config['coordinators'])
-    retflag, retdata = pvc_ceph.map_volume(zk_conn, pool, "{}_ova".format(name))
+    retflag, retdata = pvc_ceph.map_volume(zk_conn, pool, "ova_{}".format(name))
     pvc_common.stopZKConnection(zk_conn)
     if not retflag:
         output = {
@@ -107,7 +226,6 @@ def upload_ova(ova_data, ova_size, pool, name, define_vm, start_vm):
     ova_blockdev = retdata
 
     # Save the OVA data to the temporary blockdev directly
-    print("Save the OVA data to the temporary blockdev directly")
     try:
         ova_data.save(ova_blockdev)
     except:
@@ -120,10 +238,8 @@ def upload_ova(ova_data, ova_size, pool, name, define_vm, start_vm):
 
     try:
         # Set up the TAR reader for the OVA temporary blockdev
-        print("Set up the TAR reader for the OVA temporary blockdev")
         ova_archive = tarfile.open(name=ova_blockdev)
         # Determine the files in the OVA
-        print("Determine the files in the OVA")
         members = ova_archive.getmembers()
     except tarfile.TarError:
         output = {
@@ -134,109 +250,54 @@ def upload_ova(ova_data, ova_size, pool, name, define_vm, start_vm):
         return output, retcode
 
     # Parse through the members list and extract the OVF file
-    print("Parse through the members list and extract the OVF file")
     for element in set(x for x in members if re.match('.*\.ovf$', x.name)):
         ovf_file = ova_archive.extractfile(element)
-        print(ovf_file)
 
     # Parse the OVF file to get our VM details
-    print("Parse the OVF file to get our VM details")
     ovf_parser = OVFParser(ovf_file)
+    ovf_xml_raw = ovf_parser.getXML()
     virtual_system = ovf_parser.getVirtualSystems()[0]
     virtual_hardware = ovf_parser.getVirtualHardware(virtual_system)
     disk_map = ovf_parser.getDiskMap(virtual_system)
 
     # Close the OVF file
-    print("Close the OVF file")
     ovf_file.close()
 
-    print(virtual_hardware)
-    print(disk_map)
-
-    # Verify that the cluster has enough space to store all OVA disk volumes
-    total_size_bytes = 0
-    for disk in disk_map:
-        # Normalize the dev size to MB
-        print("Normalize the dev size to MB")
-        # The function always return XXXXB, so strip off the B and convert to an integer
-        dev_size_bytes = int(pvc_ceph.format_bytes_fromhuman(disk.get('capacity', 0))[:-1])
-        ova_size_bytes = int(pvc_ceph.format_bytes_fromhuman(ova_size)[:-1])
-        # Get the actual image size
-        total_size_bytes += dev_size_bytes
-        # Add on the OVA size to account for the VMDK
-        total_size_bytes += ova_size_bytes
-
-    zk_conn = pvc_common.startZKConnection(config['coordinators'])
-    pool_information = pvc_ceph.getPoolInformation(zk_conn, pool)
-    pvc_common.stopZKConnection(zk_conn)
-    pool_free_space_bytes = int(pool_information['stats']['free_bytes'])
-    if total_size_bytes >= pool_free_space_bytes:
-        output = {
-            'message': "ERROR: The cluster does not have enough free space ({}) to store the VM ({}).".format(
-                pvc_ceph.format_bytes_tohuman(pool_free_space_bytes),
-                pvc_ceph.format_bytes_tohuman(total_size_bytes)
-            )
-        }
-        retcode = 400
-        cleanup_ova_maps_and_volumes()
-        return output, retcode
-
     # Create and upload each disk volume
     for idx, disk in enumerate(disk_map):
         disk_identifier = "sd{}".format(chr(ord('a') + idx))
-        volume = "{}_{}".format(name, disk_identifier)
-        dev_size = disk.get('capacity')
+        volume = "ova_{}_{}".format(name, disk_identifier)
+        dev_src = disk.get('src')
+        dev_type = dev_src.split('.')[-1]
+        dev_size_raw = ova_archive.getmember(dev_src).size
+        vm_volume_size = disk.get('capacity')
 
-        # Normalize the dev size to MB
-        print("Normalize the dev size to MB")
+        # Normalize the dev size to KB
         # The function always return XXXXB, so strip off the B and convert to an integer
-        dev_size_bytes = int(pvc_ceph.format_bytes_fromhuman(dev_size)[:-1])
-        dev_size_mb = math.ceil(dev_size_bytes / 1024 / 1024)
-        dev_size = "{}M".format(dev_size_mb)
+        dev_size_bytes = int(pvc_ceph.format_bytes_fromhuman(dev_size_raw)[:-1])
+        dev_size_kb = math.ceil(dev_size_bytes / 1024)
+        dev_size = "{}K".format(dev_size_kb)
 
-        def cleanup_img_maps_and_volumes():
+        def cleanup_img_maps():
             zk_conn = pvc_common.startZKConnection(config['coordinators'])
-            # Unmap the target blockdev
-            retflag, retdata = pvc_ceph.unmap_volume(zk_conn, pool, volume)
             # Unmap the temporary blockdev
-            retflag, retdata = pvc_ceph.unmap_volume(zk_conn, pool, "{}_tmp".format(volume))
-            # Remove the temporary blockdev
-            retflag, retdata = pvc_ceph.remove_volume(zk_conn, pool, "{}_tmp".format(volume))
+            retflag, retdata = pvc_ceph.unmap_volume(zk_conn, pool, volume)
             pvc_common.stopZKConnection(zk_conn)
 
-        # Create target blockdev
+        # Create the blockdev
         zk_conn = pvc_common.startZKConnection(config['coordinators'])
-        pool_information = pvc_ceph.add_volume(zk_conn, pool, volume, dev_size)
-        pvc_common.stopZKConnection(zk_conn)
-       
-        # Create a temporary blockdev
-        zk_conn = pvc_common.startZKConnection(config['coordinators'])
-        retflag, retdata = pvc_ceph.add_volume(zk_conn, pool, "{}_tmp".format(volume), ova_size)
+        retflag, retdata = pvc_ceph.add_volume(zk_conn, pool, volume, dev_size)
         pvc_common.stopZKConnection(zk_conn)
         if not retflag:
             output = {
                 'message': retdata.replace('\"', '\'')
             }
             retcode = 400
-            cleanup_img_maps_and_volumes()
+            cleanup_img_maps()
             cleanup_ova_maps_and_volumes()
             return output, retcode
 
-        # Map the temporary target blockdev
-        zk_conn = pvc_common.startZKConnection(config['coordinators'])
-        retflag, retdata = pvc_ceph.map_volume(zk_conn, pool, "{}_tmp".format(volume))
-        pvc_common.stopZKConnection(zk_conn)
-        if not retflag:
-            output = {
-                'message': retdata.replace('\"', '\'')
-            }
-            retcode = 400
-            cleanup_img_maps_and_volumes()
-            cleanup_ova_maps_and_volumes()
-            return output, retcode
-        temp_blockdev = retdata
-
-        # Map the target blockdev
+        # Map the blockdev
         zk_conn = pvc_common.startZKConnection(config['coordinators'])
         retflag, retdata = pvc_ceph.map_volume(zk_conn, pool, volume)
         pvc_common.stopZKConnection(zk_conn)
@@ -245,13 +306,10 @@ def upload_ova(ova_data, ova_size, pool, name, define_vm, start_vm):
                 'message': retdata.replace('\"', '\'')
             }
             retcode = 400
-            cleanup_img_maps_and_volumes()
+            cleanup_img_maps()
             cleanup_ova_maps_and_volumes()
             return output, retcode
-        dest_blockdev = retdata
-
-        # Save the data to the temporary blockdev directly
-        img_type = disk.get('src').split('.')[-1]
+        temp_blockdev = retdata
 
         try:
             # Open (extract) the TAR archive file and seek to byte 0
@@ -268,41 +326,86 @@ def upload_ova(ova_data, ova_size, pool, name, define_vm, start_vm):
             vmdk_file.close()
             # Perform an OS-level sync
             pvc_common.run_os_command('sync')
-            # Shrink the tmp RBD image to the exact size of the written file
-            # This works around a bug in this method where an EOF is never written to the end of the
-            # target blockdev, thus causing an "Invalid footer" error. Instead, if we just shrink the
-            # RBD volume to the exact size, this is treated as an EOF
-            pvc_common.run_os_command('rbd resize {}/{}_{}_tmp --size {}B --allow-shrink'.format(pool, name, disk_identifier, bytes_written))
         except:
             output = {
                 'message': "ERROR: Failed to write image file '{}' to temporary volume.".format(disk.get('src'))
             }
             retcode = 400
-            cleanup_img_maps_and_volumes()
+            cleanup_img_maps()
             cleanup_ova_maps_and_volumes()
             return output, retcode
 
-        # Convert from the temporary to destination format on the blockdevs
-        retcode, stdout, stderr = pvc_common.run_os_command(
-            'qemu-img convert -C -f {} -O raw {} {}'.format(img_type, temp_blockdev, dest_blockdev)
-        )
-        if retcode:
-            output = {
-                'message': "ERROR: Failed to convert image '{}' format from '{}' to 'raw': {}".format(disk.get('src'), img_type, stderr)
-            }
-            retcode = 400
-            cleanup_img_maps_and_volumes()
-            cleanup_ova_maps_and_volumes()
-            return output, retcode
-
-        cleanup_img_maps_and_volumes()
+        cleanup_img_maps()
 
     cleanup_ova_maps_and_volumes()
 
-    # Prepare a VM configuration
+    # Prepare the database entries
+    query = "INSERT INTO ova (name, ovf) VALUES (%s, %s);"
+    args = (name, ovf_xml_raw)
+    conn, cur = open_database(config)
+    try:
+        cur.execute(query, args)
+        close_database(conn, cur)
+    except Exception as e:
+        output = {
+            'message': 'Failed to create OVA entry "{}": {}'.format(name, e)
+        }
+        retcode = 400
+        close_database(conn, cur)
+        return output, retcode
+
+    # Get the OVA database id
+    query = "SELECT id FROM ova WHERE name = %s;"
+    args = (name, )
+    conn, cur = open_database(config)
+    cur.execute(query, args)
+    ova_id = cur.fetchone()['id']
+    close_database(conn, cur)
+
+    # Prepare disk entries in ova_volume
+    for idx, disk in enumerate(disk_map):
+        disk_identifier = "sd{}".format(chr(ord('a') + idx))
+        volume_type = disk.get('src').split('.')[-1]
+        volume = "ova_{}_{}".format(name, disk_identifier)
+        vm_volume_size = disk.get('capacity')
+
+        # The function always return XXXXB, so strip off the B and convert to an integer
+        vm_volume_size_bytes = int(pvc_ceph.format_bytes_fromhuman(vm_volume_size)[:-1])
+        vm_volume_size_gb = math.ceil(vm_volume_size_bytes / 1024 / 1024 / 1024)
+
+        query = "INSERT INTO ova_volume (ova, pool, volume_name, volume_format, disk_id, disk_size_gb) VALUES (%s, %s, %s, %s, %s, %s);"
+        args = (ova_id, pool, volume, volume_type, disk_identifier, vm_volume_size_gb)
+
+        conn, cur = open_database(config)
+        try:
+            cur.execute(query, args)
+            close_database(conn, cur)
+        except Exception as e:
+            output = {
+                'message': 'Failed to create OVA volume entry "{}": {}'.format(volume, e)
+            }
+            retcode = 400
+            close_database(conn, cur)
+            return output, retcode
+
+    # Prepare a system_template for the OVA
+    vcpu_count = virtual_hardware.get('vcpus')
+    vram_mb = virtual_hardware.get('vram')
+    if virtual_hardware.get('graphics-controller') == 1:
+        vnc = True
+        serial = False
+    else:
+        vnc = False
+        serial = True
+    retdata, retcode = provisioner.create_template_system(name, vcpu_count, vram_mb, serial, vnc, vnc_bind=None, ova=ova_id)
+    system_template, retcode = provisioner.list_template_system(name, is_fuzzy=False)
+    system_template_name = system_template[0].get('name')
+
+    # Prepare a barebones profile for the OVA
+    retdata, retcode = provisioner.create_profile(name, 'ova', system_template_name, None, None, userdata=None, script=None, ova=name, arguments=None)
 
     output = {
-        'message': "Imported OVA file to new VM '{}'".format(name)
+        'message': "Imported OVA image '{}'".format(name)
     }
     retcode = 200
     return output, retcode
@@ -310,46 +413,38 @@ def upload_ova(ova_data, ova_size, pool, name, define_vm, start_vm):
 #
 # OVF parser
 #
-OVF_SCHEMA = "http://schemas.dmtf.org/ovf/envelope/2"
-RASD_SCHEMA = "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData"
-SASD_SCHEMA = "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_StorageAllocationSettingData.xsd"
-VSSD_SCHEMA = "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData"
-XML_SCHEMA = "http://www.w3.org/2001/XMLSchema-instance"
-
-RASD_TYPE = { 
-    "3":  "vcpus",
-    "4":  "vram",
-    "5":  "ide-controller",
-    "6":  "scsi-controller",
-    "10": "ethernet-adapter",
-    "15": "cdrom",
-    "17": "disk",
-    "20": "other-storage-device",
-    "23": "usb-controller",
-    "24": "graphics-controller",
-    "35": "sound-controller"
-}
-SASD_TYPE = {
-    "15": "cdrom",
-    "17": "disk"
-}
-
 class OVFParser(object):
+    RASD_TYPE = {
+        "1":  "vmci",
+        "3":  "vcpus",
+        "4":  "vram",
+        "5":  "ide-controller",
+        "6":  "scsi-controller",
+        "10": "ethernet-adapter",
+        "15": "cdrom",
+        "17": "disk",
+        "20": "other-storage-device",
+        "23": "usb-controller",
+        "24": "graphics-controller",
+        "35": "sound-controller"
+    }
+
     def _getFilelist(self):
-        path = "{{{schema}}}References/{{{schema}}}File".format(schema=OVF_SCHEMA)
-        id_attr = "{{{schema}}}id".format(schema=OVF_SCHEMA)
-        href_attr = "{{{schema}}}href".format(schema=OVF_SCHEMA)
+        path = "{{{schema}}}References/{{{schema}}}File".format(schema=self.OVF_SCHEMA)
+        id_attr = "{{{schema}}}id".format(schema=self.OVF_SCHEMA)
+        href_attr = "{{{schema}}}href".format(schema=self.OVF_SCHEMA)
         current_list = self.xml.findall(path) 
         results = [(x.get(id_attr), x.get(href_attr)) for x in current_list]
         return results
 
     def _getDisklist(self):
-        path = "{{{schema}}}DiskSection/{{{schema}}}Disk".format(schema=OVF_SCHEMA)
-        id_attr = "{{{schema}}}diskId".format(schema=OVF_SCHEMA)
-        ref_attr = "{{{schema}}}fileRef".format(schema=OVF_SCHEMA)
-        cap_attr = "{{{schema}}}capacity".format(schema=OVF_SCHEMA)
+        path = "{{{schema}}}DiskSection/{{{schema}}}Disk".format(schema=self.OVF_SCHEMA)
+        id_attr = "{{{schema}}}diskId".format(schema=self.OVF_SCHEMA)
+        ref_attr = "{{{schema}}}fileRef".format(schema=self.OVF_SCHEMA)
+        cap_attr = "{{{schema}}}capacity".format(schema=self.OVF_SCHEMA)
+        cap_units = "{{{schema}}}capacityAllocationUnits".format(schema=self.OVF_SCHEMA)
         current_list = self.xml.findall(path) 
-        results = [(x.get(id_attr), x.get(ref_attr), x.get(cap_attr)) for x in current_list]
+        results = [(x.get(id_attr), x.get(ref_attr), x.get(cap_attr), x.get(cap_units)) for x in current_list]
         return results
 
     def _getAttributes(self, virtual_system, path, attribute):
@@ -359,60 +454,88 @@ class OVFParser(object):
 
     def __init__(self, ovf_file):
         self.xml = lxml.etree.parse(ovf_file)
+
+        # Define our schemas
+        envelope_tag = self.xml.find(".")
+        self.XML_SCHEMA = envelope_tag.nsmap.get('xsi')
+        self.OVF_SCHEMA = envelope_tag.nsmap.get('ovf')
+        self.RASD_SCHEMA = envelope_tag.nsmap.get('rasd')
+        self.SASD_SCHEMA = envelope_tag.nsmap.get('sasd')
+        self.VSSD_SCHEMA = envelope_tag.nsmap.get('vssd')
+
+        self.ovf_version = int(self.OVF_SCHEMA.split('/')[-1])
+
+        # Get the file and disk lists
         self.filelist = self._getFilelist()
         self.disklist = self._getDisklist()
 
     def getVirtualSystems(self):
-        return self.xml.findall("{{{schema}}}VirtualSystem".format(schema=OVF_SCHEMA))
+        return self.xml.findall("{{{schema}}}VirtualSystem".format(schema=self.OVF_SCHEMA))
+
+    def getXML(self):
+        return lxml.etree.tostring(self.xml, pretty_print=True).decode('utf8')
 
     def getVirtualHardware(self, virtual_system):
         hardware_list = virtual_system.findall(
-            "{{{schema}}}VirtualHardwareSection/{{{schema}}}Item".format(schema=OVF_SCHEMA)
+            "{{{schema}}}VirtualHardwareSection/{{{schema}}}Item".format(schema=self.OVF_SCHEMA)
         )
         virtual_hardware = {}
 
         for item in hardware_list:
             try:
-                item_type = RASD_TYPE[item.find("{{{rasd}}}ResourceType".format(rasd=RASD_SCHEMA)).text]
+                item_type = self.RASD_TYPE[item.find("{{{rasd}}}ResourceType".format(rasd=self.RASD_SCHEMA)).text]
             except:
                 continue
-            quantity = item.find("{{{rasd}}}VirtualQuantity".format(rasd=RASD_SCHEMA))
+            quantity = item.find("{{{rasd}}}VirtualQuantity".format(rasd=self.RASD_SCHEMA))
             if quantity is None:
-                continue
-            print(item_type)
-            virtual_hardware[item_type] = quantity.text
+                virtual_hardware[item_type] = 1
+            else:
+                virtual_hardware[item_type] = quantity.text
 
         return virtual_hardware
 
     def getDiskMap(self, virtual_system):
-        hardware_list = virtual_system.findall(
-            "{{{schema}}}VirtualHardwareSection/{{{schema}}}StorageItem".format(schema=OVF_SCHEMA)
-        )
+        # OVF v2 uses the StorageItem field, while v1 uses the normal Item field
+        if self.ovf_version < 2:
+            hardware_list = virtual_system.findall(
+                "{{{schema}}}VirtualHardwareSection/{{{schema}}}Item".format(schema=self.OVF_SCHEMA)
+            )
+        else:
+            hardware_list = virtual_system.findall(
+                "{{{schema}}}VirtualHardwareSection/{{{schema}}}StorageItem".format(schema=self.OVF_SCHEMA)
+            )
         disk_list = []
         
         for item in hardware_list:
             item_type = None
-            try:
-                item_type = SASD_TYPE[item.find("{{{sasd}}}ResourceType".format(sasd=SASD_SCHEMA)).text]
-            except:
-                item_type = RASD_TYPE[item.find("{{{rasd}}}ResourceType".format(rasd=RASD_SCHEMA)).text]
+
+            if self.SASD_SCHEMA is not None:
+                item_type = self.RASD_TYPE[item.find("{{{sasd}}}ResourceType".format(sasd=self.SASD_SCHEMA)).text]
+            else:
+                item_type = self.RASD_TYPE[item.find("{{{rasd}}}ResourceType".format(rasd=self.RASD_SCHEMA)).text]
 
             if item_type != 'disk':
                 continue
 
             hostref = None
-            try:
-                hostref = item.find("{{{sasd}}}HostResource".format(sasd=SASD_SCHEMA))
-            except:
-                hostref = item.find("{{{rasd}}}HostResource".format(rasd=RASD_SCHEMA))
+            if self.SASD_SCHEMA is not None:
+                hostref = item.find("{{{sasd}}}HostResource".format(sasd=self.SASD_SCHEMA))
+            else:
+                hostref = item.find("{{{rasd}}}HostResource".format(rasd=self.RASD_SCHEMA))
             if hostref is None:
                 continue
             disk_res = hostref.text
 
             # Determine which file this disk_res ultimately represents
-            (disk_id, disk_ref, disk_capacity) = [x for x in self.disklist if x[0] == disk_res.split('/')[-1]][0]
+            (disk_id, disk_ref, disk_capacity, disk_capacity_unit) = [x for x in self.disklist if x[0] == disk_res.split('/')[-1]][0]
             (file_id, disk_src) = [x for x in self.filelist if x[0] == disk_ref][0]
 
+            if disk_capacity_unit is not None:
+                # Handle the unit conversion
+                base_unit, action, multiple = disk_capacity_unit.split()
+                multiple_base, multiple_exponent = multiple.split('^')
+                disk_capacity = int(disk_capacity) * ( int(multiple_base) ** int(multiple_exponent) )
+
             # Append the disk with all details to the list
             disk_list.append({
                 "id": disk_id,
diff --git a/api-daemon/pvcapid/provisioner.py b/api-daemon/pvcapid/provisioner.py
index 5d026125..0e6ba178 100755
--- a/api-daemon/pvcapid/provisioner.py
+++ b/api-daemon/pvcapid/provisioner.py
@@ -38,6 +38,8 @@ import daemon_lib.ceph as pvc_ceph
 
 import pvcapid.libvirt_schema as libvirt_schema
 
+from pvcapid.ova import list_ova
+
 #
 # Exceptions (used by Celery tasks)
 #
@@ -197,14 +199,14 @@ def template_list(limit):
 #
 # Template Create functions
 #
-def create_template_system(name, vcpu_count, vram_mb, serial=False, vnc=False, vnc_bind=None, node_limit=None, node_selector=None, node_autostart=False):
+def create_template_system(name, vcpu_count, vram_mb, serial=False, vnc=False, vnc_bind=None, node_limit=None, node_selector=None, node_autostart=False, ova=None):
     if list_template_system(name, is_fuzzy=False)[-1] != 404:
         retmsg = { 'message': 'The system template "{}" already exists'.format(name) }
         retcode = 400
         return retmsg, retcode
 
-    query = "INSERT INTO system_template (name, vcpu_count, vram_mb, serial, vnc, vnc_bind, node_limit, node_selector, node_autostart) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s);"
-    args = (name, vcpu_count, vram_mb, serial, vnc, vnc_bind, node_limit, node_selector, node_autostart)
+    query = "INSERT INTO system_template (name, vcpu_count, vram_mb, serial, vnc, vnc_bind, node_limit, node_selector, node_autostart, ova) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s);"
+    args = (name, vcpu_count, vram_mb, serial, vnc, vnc_bind, node_limit, node_selector, node_autostart, ova)
 
     conn, cur = open_database(config)
     try:
@@ -661,10 +663,6 @@ def delete_script(name):
     close_database(conn, cur)
     return retmsg, retcode
 
-#
-# OVA functions
-#
-
 #
 # Profile functions
 #
@@ -703,7 +701,8 @@ def list_profile(limit, is_fuzzy=True):
             cur.execute(query, args)
             try:
                 name = cur.fetchone()['name']
-            except:
+            except Exception as e:
+                print(e)
                 name = "N/A"
             profile_data[etype] = name
         # Split the arguments back into a list
@@ -722,8 +721,8 @@ def create_profile(name, profile_type, system_template, network_template, storag
         retcode = 400
         return retmsg, retcode
 
-    if profile_type not in ['script', 'clone', 'ova']:
-        retmsg = { 'message': 'A valid profile type (script, clone, ova) must be specified' }
+    if profile_type not in ['provisioner', 'ova']:
+        retmsg = { 'message': 'A valid profile type (provisioner, ova) must be specified' }
         retcode = 400
         return retmsg, retcode
 
@@ -742,7 +741,7 @@ def create_profile(name, profile_type, system_template, network_template, storag
     for template in network_templates:
         if template['name'] == network_template:
             network_template_id = template['id']
-    if not network_template_id:
+    if not network_template_id and profile_type != 'ova':
         retmsg = { 'message': 'The network template "{}" for profile "{}" does not exist'.format(network_template, name) }
         retcode = 400
         return retmsg, retcode
@@ -752,7 +751,7 @@ def create_profile(name, profile_type, system_template, network_template, storag
     for template in storage_templates:
         if template['name'] == storage_template:
             storage_template_id = template['id']
-    if not storage_template_id:
+    if not storage_template_id and profile_type != 'ova':
         retmsg = { 'message': 'The storage template "{}" for profile "{}" does not exist'.format(storage_template, name) }
         retcode = 400
         return retmsg, retcode
@@ -782,7 +781,7 @@ def create_profile(name, profile_type, system_template, network_template, storag
 
     conn, cur = open_database(config)
     try:
-        query = "INSERT INTO profile (name, type, system_template, network_template, storage_template, userdata, script, ova, arguments) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s);"
+        query = "INSERT INTO profile (name, profile_type, system_template, network_template, storage_template, userdata, script, ova, arguments) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s);"
         args = (name, profile_type, system_template_id, network_template_id, storage_template_id, userdata_id, script_id, ova_id, arguments_formatted)
         cur.execute(query, args)
         retmsg = { "message": 'Created VM profile "{}"'.format(name) }
@@ -802,8 +801,8 @@ def modify_profile(name, profile_type, system_template, network_template, storag
     fields = []
 
     if profile_type is not None:
-        if profile_type not in ['script', 'clone', 'ova']:
-            retmsg = { 'message': 'A valid profile type (script, clone, ova) must be specified' }
+        if profile_type not in ['provisioner', 'ova']:
+            retmsg = { 'message': 'A valid profile type (provisioner, ova) must be specified' }
             retcode = 400
             return retmsg, retcode
         fields.append({'field': 'type', 'data': profile_type})
diff --git a/client-cli/cli_lib/provisioner.py b/client-cli/cli_lib/provisioner.py
index fe9eda15..68165a2d 100644
--- a/client-cli/cli_lib/provisioner.py
+++ b/client-cli/cli_lib/provisioner.py
@@ -340,6 +340,77 @@ def script_remove(config, name):
         
     return retvalue, response.json()['message']
 
+def ova_info(config, name):
+    """
+    Get information about OVA image {name}
+
+    API endpoint: GET /api/v1/provisioner/ova/{name}
+    API arguments:
+    API schema: {json_data_object}
+    """
+    response = call_api(config, 'get', '/provisioner/ova/{name}'.format(name=name))
+
+    if response.status_code == 200:
+        return True, response.json()[0]
+    else:
+        return False, response.json()['message']
+
+def ova_list(config, limit):
+    """
+    Get list information about OVA images (limited by {limit})
+
+    API endpoint: GET /api/v1/provisioner/ova
+    API arguments: limit={limit}
+    API schema: [{json_data_object},{json_data_object},etc.]
+    """
+    params = dict()
+    if limit:
+        params['limit'] = limit
+
+    response = call_api(config, 'get', '/provisioner/ova', params=params)
+
+    if response.status_code == 200:
+        return True, response.json()
+    else:
+        return False, response.json()['message']
+
+def ova_upload(config, name, ova_file, params):
+    """
+    Upload an OVA image to the cluster
+
+    API endpoint: POST /api/v1/provisioner/ova/{name}
+    API arguments: pool={pool}, ova_size={ova_size}
+    API schema: {"message":"{data}"}
+    """
+    files = {
+        'file': open(ova_file,'rb')
+    }
+    response = call_api(config, 'post', '/provisioner/ova/{}'.format(name), params=params, files=files)
+
+    if response.status_code == 200:
+        retstatus = True
+    else:
+        retstatus = False
+
+    return retstatus, response.json()['message']
+
+def ova_remove(config, name):
+    """
+    Remove OVA image {name}
+
+    API endpoint: DELETE /api/v1/provisioner/ova/{name}
+    API_arguments:
+    API schema: {message}
+    """
+    response = call_api(config, 'delete', '/provisioner/ova/{name}'.format(name=name))
+
+    if response.status_code == 200:
+        retvalue = True
+    else:
+        retvalue = False
+        
+    return retvalue, response.json()['message']
+
 def profile_info(config, profile):
     """
     Get information about profile
@@ -1069,6 +1140,119 @@ def format_list_script(script_data, lines=None):
 
     return '\n'.join([script_list_output_header] + script_list_output)
 
+def format_list_ova(ova_data):
+    if isinstance(ova_data, dict):
+        ova_data = [ ova_data ]
+
+    ova_list_output = []
+
+    # Determine optimal column widths
+    ova_name_length = 5
+    ova_id_length = 3
+    ova_disk_id_length = 8
+    ova_disk_size_length = 10
+    ova_disk_pool_length = 5
+    ova_disk_volume_format_length = 7
+    ova_disk_volume_name_length = 13
+
+    for ova in ova_data:
+        # ova_name column
+        _ova_name_length = len(str(ova['name'])) + 1
+        if _ova_name_length > ova_name_length:
+            ova_name_length = _ova_name_length
+        # ova_id column
+        _ova_id_length = len(str(ova['id'])) + 1
+        if _ova_id_length > ova_id_length:
+            ova_id_length = _ova_id_length
+
+        for disk in ova['volumes']:
+            # ova_disk_id column
+            _ova_disk_id_length = len(str(disk['disk_id'])) + 1
+            if _ova_disk_id_length > ova_disk_id_length:
+                ova_disk_id_length = _ova_disk_id_length
+            # ova_disk_size column
+            _ova_disk_size_length = len(str(disk['disk_size_gb'])) + 1
+            if _ova_disk_size_length > ova_disk_size_length:
+                ova_disk_size_length = _ova_disk_size_length
+            # ova_disk_pool column
+            _ova_disk_pool_length = len(str(disk['pool'])) + 1
+            if _ova_disk_pool_length > ova_disk_pool_length:
+                ova_disk_pool_length = _ova_disk_pool_length
+            # ova_disk_volume_format column
+            _ova_disk_volume_format_length = len(str(disk['volume_format'])) + 1
+            if _ova_disk_volume_format_length > ova_disk_volume_format_length:
+                ova_disk_volume_format_length = _ova_disk_volume_format_length
+            # ova_disk_volume_name column
+            _ova_disk_volume_name_length = len(str(disk['volume_name'])) + 1
+            if _ova_disk_volume_name_length > ova_disk_volume_name_length:
+                ova_disk_volume_name_length = _ova_disk_volume_name_length
+
+    # Format the string (header)
+    ova_list_output_header = '{bold}{ova_name: <{ova_name_length}} {ova_id: <{ova_id_length}} \
+{ova_disk_id: <{ova_disk_id_length}} \
+{ova_disk_size: <{ova_disk_size_length}} \
+{ova_disk_pool: <{ova_disk_pool_length}} \
+{ova_disk_volume_format: <{ova_disk_volume_format_length}} \
+{ova_disk_volume_name: <{ova_disk_volume_name_length}}{end_bold}'.format(
+            ova_name_length=ova_name_length,
+            ova_id_length=ova_id_length,
+            ova_disk_id_length=ova_disk_id_length,
+            ova_disk_pool_length=ova_disk_pool_length,
+            ova_disk_size_length=ova_disk_size_length,
+            ova_disk_volume_format_length=ova_disk_volume_format_length,
+            ova_disk_volume_name_length=ova_disk_volume_name_length,
+            bold=ansiprint.bold(),
+            end_bold=ansiprint.end(),
+            ova_name='Name',
+            ova_id='ID',
+            ova_disk_id='Disk ID',
+            ova_disk_size='Size [GB]',
+            ova_disk_pool='Pool',
+            ova_disk_volume_format='Format',
+            ova_disk_volume_name='Source Volume',
+        )
+
+    # Format the string (elements)
+    for ova in sorted(ova_data, key=lambda i: i.get('name', None)):
+        ova_list_output.append(
+            '{bold}{ova_name: <{ova_name_length}} {ova_id: <{ova_id_length}}{end_bold}'.format(
+                ova_name_length=ova_name_length,
+                ova_id_length=ova_id_length,
+                bold='',
+                end_bold='',
+                ova_name=str(ova['name']),
+                ova_id=str(ova['id'])
+            )
+        )
+        for disk in sorted(ova['volumes'], key=lambda i: i.get('disk_id', None)):
+            ova_list_output.append(
+                '{bold}{ova_name: <{ova_name_length}} {ova_id: <{ova_id_length}} \
+{ova_disk_id: <{ova_disk_id_length}} \
+{ova_disk_size: <{ova_disk_size_length}} \
+{ova_disk_pool: <{ova_disk_pool_length}} \
+{ova_disk_volume_format: <{ova_disk_volume_format_length}} \
+{ova_disk_volume_name: <{ova_disk_volume_name_length}}{end_bold}'.format(
+                    ova_name_length=ova_name_length,
+                    ova_id_length=ova_id_length,
+                    ova_disk_id_length=ova_disk_id_length,
+                    ova_disk_size_length=ova_disk_size_length,
+                    ova_disk_pool_length=ova_disk_pool_length,
+                    ova_disk_volume_format_length=ova_disk_volume_format_length,
+                    ova_disk_volume_name_length=ova_disk_volume_name_length,
+                    bold='',
+                    end_bold='',
+                    ova_name='',
+                    ova_id='',
+                    ova_disk_id=str(disk['disk_id']),
+                    ova_disk_size=str(disk['disk_size_gb']),
+                    ova_disk_pool=str(disk['pool']),
+                    ova_disk_volume_format=str(disk['volume_format']),
+                    ova_disk_volume_name=str(disk['volume_name']),
+                )
+            )
+
+    return '\n'.join([ova_list_output_header] + ova_list_output)
+
 def format_list_profile(profile_data):
     if isinstance(profile_data, dict):
         profile_data = [ profile_data ]
@@ -1078,7 +1262,7 @@ def format_list_profile(profile_data):
         profile_type = profile['type']
         if 'ova' in profile_type:
             # Set the source to the name of the OVA:
-            profile['source'] = profile_data['ova']
+            profile['source'] = 'OVA {}'.format(profile['ova'])
         else:
             # Set the source to be the type
             profile['source'] = profile_type
diff --git a/client-cli/pvc.py b/client-cli/pvc.py
index 9abbb2dd..fb2a16cf 100755
--- a/client-cli/pvc.py
+++ b/client-cli/pvc.py
@@ -2833,6 +2833,99 @@ def provisioner_script_remove(name, confirm_flag):
     cleanup(retcode, retdata)
 
 
+###############################################################################
+# pvc provisioner ova
+###############################################################################
+@click.group(name='ova', short_help='Manage PVC provisioner OVA images.', context_settings=CONTEXT_SETTINGS)
+def provisioner_ova():
+    """
+    Manage ovas in the PVC provisioner.
+    """
+    # Abort commands under this group if config is bad
+    if config.get('badcfg', None):
+        click.echo('No cluster specified and no local pvcapid.yaml configuration found. Use "pvc cluster" to add a cluster API to connect to.')
+        exit(1)
+
+###############################################################################
+# pvc provisioner ova list
+###############################################################################
+@click.command(name='list', short_help='List all OVA images.')
+@click.argument(
+    'limit', default=None, required=False
+)
+def provisioner_ova_list(limit):
+    """
+    List all OVA images in the PVC cluster provisioner.
+    """
+    retcode, retdata = pvc_provisioner.ova_list(config, limit)
+    if retcode:
+        retdata = pvc_provisioner.format_list_ova(retdata)
+    cleanup(retcode, retdata)
+
+###############################################################################
+# pvc provisioner ova upload
+###############################################################################
+@click.command(name='upload', short_help='Upload OVA file.')
+@click.argument(
+    'name'
+)
+@click.argument(
+    'filename'
+)
+@click.option(
+    '-p', '--pool', 'pool',
+    required=True,
+    help='The storage pool for the OVA images.'
+)
+def provisioner_ova_upload(name, filename, pool):
+    """
+    Upload a new OVA image NAME from FILENAME.
+
+    Only single-file (.ova) OVA/OVF images are supported. For multi-file (.ovf + .vmdk) OVF images, concatenate them with "tar" then upload the resulting file.
+
+    Once uploaded, a provisioner system template and OVA-type profile, each named NAME, will be created to store the configuration of the OVA.
+
+    Note that the provisioner profile for the OVA will not contain any network template definitions, and will ignore network definitions from the OVA itself. The administrator must modify the profile's network template as appropriate to set the desired network configuration.
+
+    Storage templates, provisioning scripts, and arguments for OVA-type profiles will be ignored and should not be set.
+    """
+    if not os.path.exists(filename):
+        click.echo("ERROR: File '{}' does not exist!".format(filename))
+        exit(1)
+
+    params = dict()
+    params['pool'] = pool
+    params['ova_size'] = os.path.getsize(filename)
+
+    retcode, retdata = pvc_provisioner.ova_upload(config, name, filename, params)
+    cleanup(retcode, retdata)
+
+###############################################################################
+# pvc provisioner ova remove
+###############################################################################
+@click.command(name='remove', short_help='Remove OVA image.')
+@click.argument(
+    'name'
+)
+@click.option(
+    '-y', '--yes', 'confirm_flag',
+    is_flag=True, default=False,
+    help='Confirm the removal'
+)
+def provisioner_ova_remove(name, confirm_flag):
+    """
+    Remove OVA image NAME from the PVC cluster provisioner.
+    """
+    if not confirm_flag:
+        try:
+            click.confirm('Remove ova {}'.format(name), prompt_suffix='? ', abort=True)
+        except:
+            exit(0)
+
+    retcode, retdata = pvc_provisioner.ova_remove(config, name)
+    cleanup(retcode, retdata)
+
+
 ###############################################################################
 # pvc provisioner profile
 ###############################################################################
@@ -2869,47 +2962,54 @@ def provisioner_profile_list(limit):
 @click.argument(
     'name'
 )
+@click.option(
+    '-p', '--profile-type', 'profile_type',
+    default='provisioner', show_default=True,
+    type=click.Choice(['provisioner', 'ova'], case_sensitive=False),
+    help='The type of profile.'
+)
 @click.option(
     '-s', '--system-template', 'system_template',
-    required=True,
     help='The system template for the profile.'
 )
 @click.option(
     '-n', '--network-template', 'network_template',
-    required=True,
     help='The network template for the profile.'
 )
 @click.option(
     '-t', '--storage-template', 'storage_template',
-    required=True,
     help='The storage template for the profile.'
 )
 @click.option(
     '-u', '--userdata', 'userdata',
-    required=True,
     help='The userdata document for the profile.'
 )
 @click.option(
     '-x', '--script', 'script',
-    required=True,
     help='The script for the profile.'
 )
+@click.option(
+    '-o', '--ova', 'ova',
+    help='The OVA image for the profile.'
+)
 @click.option(
     '-a', '--script-arg', 'script_args',
     default=[], multiple=True,
     help='Additional argument to the script install() function in key=value format.'
 )
-def provisioner_profile_add(name, system_template, network_template, storage_template, userdata, script, script_args):
+def provisioner_profile_add(name, profile_type, system_template, network_template, storage_template, userdata, script, ova, script_args):
     """
     Add a new provisioner profile NAME.
     """
     params = dict()
     params['name'] = name
+    params['profile_type'] = profile_type
     params['system_template'] = system_template
     params['network_template'] = network_template
     params['storage_template'] = storage_template
     params['userdata'] = userdata
     params['script'] = script
+    params['ova'] = ova
     params['arg'] = script_args
 
     retcode, retdata = pvc_provisioner.profile_add(config, params)
@@ -3362,6 +3462,10 @@ provisioner_script.add_command(provisioner_script_add)
 provisioner_script.add_command(provisioner_script_modify)
 provisioner_script.add_command(provisioner_script_remove)
 
+provisioner_ova.add_command(provisioner_ova_list)
+provisioner_ova.add_command(provisioner_ova_upload)
+provisioner_ova.add_command(provisioner_ova_remove)
+
 provisioner_profile.add_command(provisioner_profile_list)
 provisioner_profile.add_command(provisioner_profile_add)
 provisioner_profile.add_command(provisioner_profile_modify)
@@ -3370,6 +3474,7 @@ provisioner_profile.add_command(provisioner_profile_remove)
 cli_provisioner.add_command(provisioner_template)
 cli_provisioner.add_command(provisioner_userdata)
 cli_provisioner.add_command(provisioner_script)
+cli_provisioner.add_command(provisioner_ova)
 cli_provisioner.add_command(provisioner_profile)
 cli_provisioner.add_command(provisioner_create)
 cli_provisioner.add_command(provisioner_status)
diff --git a/docs/manuals/swagger.json b/docs/manuals/swagger.json
index 38efc153..f388080f 100644
--- a/docs/manuals/swagger.json
+++ b/docs/manuals/swagger.json
@@ -554,6 +554,48 @@
             },
             "type": "object"
         },
+        "ova": {
+            "properties": {
+                "id": {
+                    "description": "Internal provisioner OVA ID",
+                    "type": "integer"
+                },
+                "name": {
+                    "description": "OVA name",
+                    "type": "string"
+                },
+                "volumes": {
+                    "items": {
+                        "id": "ova_volume",
+                        "properties": {
+                            "disk_id": {
+                                "description": "Disk identifier",
+                                "type": "string"
+                            },
+                            "disk_size_gb": {
+                                "description": "Disk size in GB",
+                                "type": "string"
+                            },
+                            "pool": {
+                                "description": "Pool containing the OVA volume",
+                                "type": "string"
+                            },
+                            "volume_format": {
+                                "description": "OVA image format",
+                                "type": "string"
+                            },
+                            "volume_name": {
+                                "description": "Storage volume containing the OVA image",
+                                "type": "string"
+                            }
+                        },
+                        "type": "object"
+                    },
+                    "type": "list"
+                }
+            },
+            "type": "object"
+        },
         "pool": {
             "properties": {
                 "name": {
@@ -2190,6 +2232,160 @@
                 ]
             }
         },
+        "/api/v1/provisioner/ova": {
+            "get": {
+                "description": "",
+                "parameters": [
+                    {
+                        "description": "An OVA name search limit; fuzzy by default, use ^/$ to force exact matches",
+                        "in": "query",
+                        "name": "limit",
+                        "required": false,
+                        "type": "string"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "items": {
+                                "$ref": "#/definitions/ova"
+                            },
+                            "type": "list"
+                        }
+                    }
+                },
+                "summary": "Return a list of OVA sources",
+                "tags": [
+                    "provisioner"
+                ]
+            },
+            "post": {
+                "description": "<br/>The API client is responsible for determining and setting the ova_size value, as this value cannot be determined dynamically before the upload proceeds.",
+                "parameters": [
+                    {
+                        "description": "Storage pool name",
+                        "in": "query",
+                        "name": "pool",
+                        "required": true,
+                        "type": "string"
+                    },
+                    {
+                        "description": "OVA name on the cluster (usually identical to the OVA file name)",
+                        "in": "query",
+                        "name": "name",
+                        "required": true,
+                        "type": "string"
+                    },
+                    {
+                        "description": "Size of the OVA file in bytes",
+                        "in": "query",
+                        "name": "ova_size",
+                        "required": true,
+                        "type": "string"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/Message"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad request",
+                        "schema": {
+                            "$ref": "#/definitions/Message"
+                        }
+                    }
+                },
+                "summary": "Upload an OVA image to the cluster",
+                "tags": [
+                    "provisioner"
+                ]
+            }
+        },
+        "/api/v1/provisioner/ova/{ova}": {
+            "delete": {
+                "description": "",
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/Message"
+                        }
+                    },
+                    "404": {
+                        "description": "Not found",
+                        "schema": {
+                            "$ref": "#/definitions/Message"
+                        }
+                    }
+                },
+                "summary": "Remove ova {ova}",
+                "tags": [
+                    "provisioner"
+                ]
+            },
+            "get": {
+                "description": "",
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/ova"
+                        }
+                    },
+                    "404": {
+                        "description": "Not found",
+                        "schema": {
+                            "$ref": "#/definitions/Message"
+                        }
+                    }
+                },
+                "summary": "Return information about OVA image {ova}",
+                "tags": [
+                    "provisioner"
+                ]
+            },
+            "post": {
+                "description": "<br/>The API client is responsible for determining and setting the ova_size value, as this value cannot be determined dynamically before the upload proceeds.",
+                "parameters": [
+                    {
+                        "description": "Storage pool name",
+                        "in": "query",
+                        "name": "pool",
+                        "required": true,
+                        "type": "string"
+                    },
+                    {
+                        "description": "Size of the OVA file in bytes",
+                        "in": "query",
+                        "name": "ova_size",
+                        "required": true,
+                        "type": "string"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/Message"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad request",
+                        "schema": {
+                            "$ref": "#/definitions/Message"
+                        }
+                    }
+                },
+                "summary": "Upload an OVA image to the cluster",
+                "tags": [
+                    "provisioner"
+                ]
+            }
+        },
         "/api/v1/provisioner/profile": {
             "get": {
                 "description": "",
@@ -2228,39 +2424,57 @@
                         "required": true,
                         "type": "string"
                     },
+                    {
+                        "description": "Profile type",
+                        "enum": [
+                            "provisioner",
+                            "ova"
+                        ],
+                        "in": "query",
+                        "name": "profile_type",
+                        "required": true,
+                        "type": "string"
+                    },
                     {
                         "description": "Script name",
                         "in": "query",
                         "name": "script",
-                        "required": true,
+                        "required": false,
                         "type": "string"
                     },
                     {
                         "description": "System template name",
                         "in": "query",
                         "name": "system_template",
-                        "required": true,
+                        "required": false,
                         "type": "string"
                     },
                     {
                         "description": "Network template name",
                         "in": "query",
                         "name": "network_template",
-                        "required": true,
+                        "required": false,
                         "type": "string"
                     },
                     {
                         "description": "Storage template name",
                         "in": "query",
                         "name": "storage_template",
-                        "required": true,
+                        "required": false,
                         "type": "string"
                     },
                     {
                         "description": "Userdata template name",
                         "in": "query",
                         "name": "userdata",
-                        "required": true,
+                        "required": false,
+                        "type": "string"
+                    },
+                    {
+                        "description": "OVA image source",
+                        "in": "query",
+                        "name": "ova",
+                        "required": false,
                         "type": "string"
                     },
                     {
@@ -2336,6 +2550,17 @@
             "post": {
                 "description": "",
                 "parameters": [
+                    {
+                        "description": "Profile type",
+                        "enum": [
+                            "provisioner",
+                            "ova"
+                        ],
+                        "in": "query",
+                        "name": "profile_type",
+                        "required": true,
+                        "type": "string"
+                    },
                     {
                         "description": "Script name",
                         "in": "query",
@@ -2371,6 +2596,13 @@
                         "required": true,
                         "type": "string"
                     },
+                    {
+                        "description": "OVA image source",
+                        "in": "query",
+                        "name": "ova",
+                        "required": false,
+                        "type": "string"
+                    },
                     {
                         "description": "Script install() function keywork argument in \"arg=data\" format; may be specified multiple times to add multiple arguments",
                         "in": "query",