Merge pull request #13 from cloudify-incubator/storage-support

Storage support

Author: EarthmanT

CHANGELOG.txt

@@ -26,3 +26,8 @@ releases:
     * move use_external_resource to top of instance properties
     * add `update` action for sync vm size to values from runtime properties.
     * rename `memory_size` to `memory_maxsize`
+
+  v0.7.0:
+    * Support storage pool creation.
+    * Rename `params.resource_id` to `params.name`.
+    * Support creation snapshot on external resources.

README.md

@@ -46,6 +46,7 @@ Description for VM
 * `resource_id`: (optional) Used to identify the object when
   `use_external_resource` is true.
 * `params`: params used for create object, useful for embeded template.
+  * `name`: Domain name
   * `vcpu`: CPU count
   * `memory_size`: VM memory size in KiB
   * `memory_maxsize`: (optional) recomended VM memory size in KiB for
@@ -62,7 +63,7 @@ Description for VM
 **Inputs for actions:**
 * `configure`:
   * `params`: list of params for template, can be empty
-  * `domain_file`: Template for domain. Defaults is
+  * `template_resource`: Template for domain. Defaults is
     [domain.xml](cloudify_libvirt/templates/domain.xml)
 
 **Runtime properties:**
@@ -80,14 +81,15 @@ Description for Network
 * `resource_id`: (optional) Used to identify the object when
   `use_external_resource` is true.
 * `params`: params used for create object.
+  * `name`: Network name
   * `dev`: Device name
   * `forwards`: settings for network `forwards`.
   * `ips`: settings for network `ips`.
 
 **Inputs for actions:**
 * `create`:
   * `params`: list of params for template, can be empty
-  * `network_file`: Template for network. Defaults is
+  * `template_resource`: Template for network. Defaults is
     [network.xml](cloudify_libvirt/templates/network.xml)
 
 **Runtime properties:**

cloudify_libvirt/common.py

@@ -13,6 +13,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import os
+import uuid
+from jinja2 import Template
+from pkg_resources import resource_filename
+
 from cloudify import ctx
 from cloudify import exceptions as cfy_exc
 
@@ -32,6 +36,12 @@ def get_libvirt_params(**kwargs):
     template_params.update(kwargs.get('params', {}))
     ctx.instance.runtime_properties['params'] = template_params
 
+    # set default names and instance_uuid
+    if not template_params.get("name"):
+        template_params["name"] = ctx.instance.id
+    if not template_params.get("instance_uuid"):
+        template_params["instance_uuid"] = str(uuid.uuid4())
+
     # update 'resource_id', 'use_external_resource' from kwargs
     for field in ['resource_id', 'use_external_resource']:
         if field in kwargs:
@@ -40,12 +50,38 @@ def get_libvirt_params(**kwargs):
     return libvirt_auth, template_params
 
 
+def gen_xml_template(kwargs, template_params, default_template):
+    # templates
+    template_resource = kwargs.get('template_resource')
+    template_content = kwargs.get('template_content')
+
+    if template_resource:
+        template_content = ctx.get_resource(template_resource)
+
+    if not (template_resource or template_content):
+        resource_dir = resource_filename(__name__, 'templates')
+        template_resource = '{}/{}.xml'.format(resource_dir, default_template)
+        ctx.logger.info("Will be used internal: %s" % template_resource)
+
+    if not template_content:
+        with open(template_resource) as object_desc:
+            template_content = object_desc.read()
+
+    template_engine = Template(template_content)
+    params = {"ctx": ctx}
+    if template_params:
+        params.update(template_params)
+    xmlconfig = template_engine.render(params)
+    ctx.logger.debug(repr(xmlconfig))
+    return xmlconfig
+
+
 def get_backupname(kwargs):
     if not kwargs.get("snapshot_name"):
         raise cfy_exc.NonRecoverableError(
             'Backup name must be provided.'
         )
-    return kwargs["snapshot_name"]
+    return "{}-{}".format(ctx.instance.id, kwargs["snapshot_name"])
 
 
 def get_backupdir(kwargs):
@@ -99,3 +135,71 @@ def delete_binary_place(backup_dir, object_name):
     full_path = get_binary_place(backup_dir, object_name)
     if os.path.isfile(full_path):
         os.remove(full_path)
+
+
+def xml_snapshot_create(kwargs, resource_id, current_xmldump):
+    snapshot_name = get_backupname(kwargs)
+    if kwargs.get("snapshot_incremental"):
+        backups = ctx.instance.runtime_properties.get("backups", {})
+        if snapshot_name in backups:
+            raise cfy_exc.NonRecoverableError(
+                "Snapshot {snapshot_name} already exists."
+                .format(snapshot_name=snapshot_name,))
+        backups[snapshot_name] = current_xmldump
+        ctx.instance.runtime_properties["backups"] = backups
+        ctx.logger.info("Snapshot {snapshot_name} is created."
+                        .format(snapshot_name=snapshot_name,))
+    else:
+        if read_node_state(get_backupdir(kwargs), resource_id):
+            raise cfy_exc.NonRecoverableError(
+                "Backup {snapshot_name} already exists."
+                .format(snapshot_name=snapshot_name,))
+        save_node_state(get_backupdir(kwargs), resource_id, current_xmldump)
+    ctx.logger.info("Backup {snapshot_name} is created."
+                    .format(snapshot_name=snapshot_name,))
+    ctx.logger.debug("Current config {}".format(repr(current_xmldump)))
+
+
+def xml_snapshot_apply(kwargs, resource_id, current_xmldump):
+    snapshot_name = get_backupname(kwargs)
+    if kwargs.get("snapshot_incremental"):
+        backups = ctx.instance.runtime_properties.get("backups", {})
+        if snapshot_name not in backups:
+            raise cfy_exc.NonRecoverableError(
+                "No snapshots found with name: {snapshot_name}."
+                .format(snapshot_name=snapshot_name,))
+        xml_backup = backups[snapshot_name]
+    else:
+        xml_backup = read_node_state(get_backupdir(kwargs), resource_id)
+        if not xml_backup:
+            raise cfy_exc.NonRecoverableError(
+                "No backups found with name: {snapshot_name}."
+                .format(snapshot_name=snapshot_name,))
+
+    if xml_backup.strip() != current_xmldump.strip():
+        ctx.logger.info("We have different configs,\n{}\nvs\n{}\n"
+                        .format(
+                            repr(xml_backup.strip()),
+                            repr(current_xmldump.strip())))
+    else:
+        ctx.logger.info("Already used such configuration: {}"
+                        .format(snapshot_name))
+
+
+def xml_snapshot_delete(kwargs, resource_id):
+    snapshot_name = get_backupname(kwargs)
+    if kwargs.get("snapshot_incremental"):
+        backups = ctx.instance.runtime_properties.get("backups", {})
+        if snapshot_name not in backups:
+            raise cfy_exc.NonRecoverableError(
+                "No snapshots found with name: {snapshot_name}."
+                .format(snapshot_name=snapshot_name,))
+        del backups[snapshot_name]
+        ctx.instance.runtime_properties["backups"] = backups
+    else:
+        if not read_node_state(get_backupdir(kwargs), resource_id):
+            raise cfy_exc.NonRecoverableError(
+                "No backups found with name: {snapshot_name}."
+                .format(snapshot_name=snapshot_name,))
+        delete_node_state(get_backupdir(kwargs), resource_id)
+    ctx.logger.info("Backup deleted: {}".format(snapshot_name))

cloudify_libvirt/domain_tasks.py

@@ -15,13 +15,10 @@
 
 import libvirt
 import time
-import uuid
 
-from jinja2 import Template
 from cloudify import ctx
 from cloudify.decorators import operation
 from cloudify import exceptions as cfy_exc
-from pkg_resources import resource_filename
 import cloudify_libvirt.common as common
 
 
@@ -35,22 +32,14 @@ def create(**kwargs):
 
 def _update_template_params(template_params):
     # set all params to default values
-    if not template_params:
-        template_params = {}
-
-    if not template_params.get("resource_id"):
-        template_params["resource_id"] = ctx.instance.id
     if (not template_params.get("memory_maxsize") and
             template_params.get('memory_size')):
         # if have no maximum memory size, set current as minimum
         # and twised memory as maximum
         memory_size = int(template_params['memory_size'])
         template_params['memory_maxsize'] = memory_size * 2
-    if not template_params.get("instance_uuid"):
-        template_params["instance_uuid"] = str(uuid.uuid4())
     if not template_params.get("domain_type"):
         template_params["domain_type"] = "qemu"
-    return template_params
 
 
 @operation
@@ -64,8 +53,7 @@ def configure(**kwargs):
             'Failed to open connection to the hypervisor'
         )
 
-    template_params = _update_template_params(template_params)
-
+    _update_template_params(template_params)
     try:
         if ctx.instance.runtime_properties.get("use_external_resource"):
             # lookup the default domain by name
@@ -83,29 +71,7 @@ def configure(**kwargs):
             ctx.instance.runtime_properties['use_external_resource'] = True
             return
 
-        # templates
-        domain_file = kwargs.get('domain_file')
-        domain_template = kwargs.get('domain_template')
-
-        if domain_file:
-            domain_template = ctx.get_resource(domain_file)
-
-        if not (domain_file or domain_template):
-            resource_dir = resource_filename(__name__, 'templates')
-            domain_file = '{}/domain.xml'.format(resource_dir)
-            ctx.logger.info("Will be used internal: %s" % domain_file)
-
-        if not domain_template:
-            with open(domain_file) as domain_desc:
-                domain_template = domain_desc.read()
-
-        template_engine = Template(domain_template)
-        params = {"ctx": ctx}
-        params.update(template_params)
-        xmlconfig = template_engine.render(params)
-
-        ctx.logger.debug(repr(xmlconfig))
-
+        xmlconfig = common.gen_xml_template(kwargs, template_params, 'domain')
         dom = conn.defineXML(xmlconfig)
         if dom is None:
             raise cfy_exc.NonRecoverableError(
@@ -598,35 +564,15 @@ def snapshot_create(**kwargs):
             )
 
         if kwargs.get("snapshot_incremental"):
-            backup_file = kwargs.get('backup_file')
-            backup_template = kwargs.get('backup_template')
             snapshot_type = kwargs.get('snapshot_type')
 
-            if backup_file:
-                backup_template = ctx.get_resource(backup_file)
-
-            if not backup_file and not backup_template:
-                resource_dir = resource_filename(__name__, 'templates')
-                backup_file = '{}/snapshot.xml'.format(resource_dir)
-                ctx.logger.info("Will be used internal: %s" % backup_file)
-
-            if not backup_template:
-                with open(backup_file) as backup_desc:
-                    backup_template = backup_desc.read()
-
-            template_engine = Template(backup_template)
-            if not template_params:
-                template_params = {}
-
             params = {
-                "ctx": ctx,
                 'snapshot_name': snapshot_name,
                 'snapshot_description': snapshot_type
             }
-            params.update(template_params)
-            xmlconfig = template_engine.render(params)
-
-            ctx.logger.debug(repr(xmlconfig))
+            if template_params:
+                params.update(template_params)
+            xmlconfig = common.gen_xml_template(kwargs, params, 'snapshot')
 
             try:
                 # will raise exception if unexist