unified snapshot logic

Author: 0lvin

cloudify_libvirt/common.py

@@ -128,3 +128,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/network_tasks.py

@@ -141,7 +141,6 @@ def snapshot_create(**kwargs):
         # not uninstall workflow, raise exception
         raise cfy_exc.NonRecoverableError("No network for backup")
 
-    snapshot_name = common.get_backupname(kwargs)
     libvirt_auth, _ = common.get_libvirt_params(**kwargs)
     conn = libvirt.open(libvirt_auth)
     if conn is None:
@@ -158,28 +157,7 @@ def snapshot_create(**kwargs):
                 'Failed to find the network: {}'.format(repr(e))
             )
 
-        net_backup = network.XMLDesc()
-        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] = net_backup
-            ctx.instance.runtime_properties["backups"] = backups
-            ctx.logger.info("Snapshot {snapshot_name} is created."
-                            .format(snapshot_name=snapshot_name,))
-        else:
-            if common.read_node_state(common.get_backupdir(kwargs),
-                                      resource_id):
-                raise cfy_exc.NonRecoverableError(
-                    "Backup {snapshot_name} already exists."
-                    .format(snapshot_name=snapshot_name,))
-            common.save_node_state(common.get_backupdir(kwargs), resource_id,
-                                   net_backup)
-        ctx.logger.info("Backup {snapshot_name} is created."
-                        .format(snapshot_name=snapshot_name,))
-        ctx.logger.debug("Current config {}".format(repr(net_backup)))
+        common.xml_snapshot_create(kwargs, resource_id, network.XMLDesc())
     finally:
         conn.close()
 
@@ -193,8 +171,6 @@ def snapshot_apply(**kwargs):
         # not uninstall workflow, raise exception
         raise cfy_exc.NonRecoverableError("No network for restore")
 
-    snapshot_name = common.get_backupname(kwargs)
-
     libvirt_auth, _ = common.get_libvirt_params(**kwargs)
     conn = libvirt.open(libvirt_auth)
     if conn is None:
@@ -211,29 +187,7 @@ def snapshot_apply(**kwargs):
                 'Failed to find the network: {}'.format(repr(e))
             )
 
-        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,))
-            net_backup = backups[snapshot_name]
-        else:
-            net_backup = common.read_node_state(common.get_backupdir(kwargs),
-                                                resource_id)
-            if not net_backup:
-                raise cfy_exc.NonRecoverableError(
-                    "No backups found with name: {snapshot_name}."
-                    .format(snapshot_name=snapshot_name,))
-
-        if net_backup.strip() != network.XMLDesc().strip():
-            ctx.logger.info("We have different configs,\n{}\nvs\n{}\n"
-                            .format(
-                                repr(net_backup.strip()),
-                                repr(network.XMLDesc().strip())))
-        else:
-            ctx.logger.info("Already used such configuration: {}"
-                            .format(snapshot_name))
+        common.xml_snapshot_apply(kwargs, resource_id, network.XMLDesc())
     finally:
         conn.close()
 
@@ -247,23 +201,7 @@ def snapshot_delete(**kwargs):
         # not uninstall workflow, raise exception
         raise cfy_exc.NonRecoverableError("No network for backup delete")
 
-    snapshot_name = common.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 common.read_node_state(common.get_backupdir(kwargs),
-                                      resource_id):
-            raise cfy_exc.NonRecoverableError(
-                "No backups found with name: {snapshot_name}."
-                .format(snapshot_name=snapshot_name,))
-        common.delete_node_state(common.get_backupdir(kwargs), resource_id)
-    ctx.logger.info("Backup deleted: {}".format(snapshot_name))
+    common.xml_snapshot_delete(kwargs, resource_id)
 
 
 @operation

cloudify_libvirt/tests/test_common_base.py

@@ -147,23 +147,25 @@ def _test_no_resource_id(self, func, exception_text=None):
             ):
                 func(ctx=_ctx)
 
-    def _test_reused_object(self, func, use_existed=True):
+    def _test_reused_object(self, libvirt_open, func, use_existed=True):
         # check use prexisted object
         _ctx = self._create_ctx()
         _ctx.instance.runtime_properties['resource_id'] = 'resource'
         _ctx.instance.runtime_properties['use_external_resource'] = use_existed
         connect = self._create_fake_connection()
-        with mock.patch(
-            "cloudify_libvirt.network_tasks.libvirt.open",
-            mock.Mock(return_value=connect)
-        ):
+        with mock.patch(libvirt_open, mock.Mock(return_value=connect)):
             func(ctx=_ctx)
 
-    def _test_no_snapshot_name(self, _ctx, func):
+    def _test_no_snapshot_name(self, _ctx, libvirt_open, func):
         _ctx.instance.runtime_properties['resource_id'] = 'resource'
 
         with self.assertRaisesRegexp(
             NonRecoverableError,
             "Backup name must be provided."
         ):
-            func(ctx=_ctx)
+            connect = self._create_fake_connection()
+            connect.networkLookupByName = mock.Mock()
+            connect.lookupByName = mock.Mock()
+            connect.storagePoolLookupByName = mock.Mock()
+            with mock.patch(libvirt_open, mock.Mock(return_value=connect)):
+                func(ctx=_ctx)

cloudify_libvirt/tests/test_domain.py

@@ -192,7 +192,9 @@ def test_start(self):
 
     def test_stop(self):
         self._test_no_resource_id(domain_tasks.stop)
-        self._test_reused_object(domain_tasks.stop)
+        self._test_reused_object(
+            "cloudify_libvirt.domain_tasks.libvirt.open",
+            domain_tasks.stop)
         self._test_check_correct_connect_action(domain_tasks.stop)
         self._test_check_correct_connect_no_object(domain_tasks.stop)
         self._test_action_states(
@@ -222,7 +224,9 @@ def test_suspend(self):
 
     def test_delete(self):
         self._test_no_resource_id(domain_tasks.delete)
-        self._test_reused_object(domain_tasks.delete)
+        self._test_reused_object(
+            "cloudify_libvirt.domain_tasks.libvirt.open",
+            domain_tasks.delete)
         self._test_check_correct_connect_action(domain_tasks.delete)
         self._test_check_correct_connect_no_object(domain_tasks.delete)
 
@@ -890,7 +894,10 @@ def _test_check_correct_connect_backup_no_object(self, func):
     def _test_common_backups(self, func, noresource_text):
         # common funcs for backups
         self._test_no_resource_id(func, noresource_text)
-        self._test_no_snapshot_name(self._create_ctx(), func)
+        self._test_no_snapshot_name(
+            self._create_ctx(),
+            "cloudify_libvirt.domain_tasks.libvirt.open",
+            func)
         self._test_snapshot_name_backup(func)
         self._test_check_correct_connect_backup(func)
         self._test_check_correct_connect_backup_no_object(func)

cloudify_libvirt/tests/test_network.py

@@ -227,8 +227,10 @@ def _create_fake_network_backup(self):
     def test_snapshot_apply(self):
         self._test_no_resource_id(network_tasks.snapshot_apply,
                                   "No network for restore")
-        self._test_no_snapshot_name(self._create_ctx(),
-                                    network_tasks.snapshot_apply)
+        self._test_no_snapshot_name(
+            self._create_ctx(),
+            "cloudify_libvirt.network_tasks.libvirt.open",
+            network_tasks.snapshot_apply)
         self._test_empty_connection_backup(network_tasks.snapshot_apply)
         self._test_empty_network_backup(network_tasks.snapshot_apply)
 
@@ -297,8 +299,10 @@ def test_snapshot_apply(self):
     def test_snapshot_create(self):
         self._test_no_resource_id(network_tasks.snapshot_create,
                                   "No network for backup")
-        self._test_no_snapshot_name(self._create_ctx(),
-                                    network_tasks.snapshot_create)
+        self._test_no_snapshot_name(
+            self._create_ctx(),
+            "cloudify_libvirt.network_tasks.libvirt.open",
+            network_tasks.snapshot_create)
         self._test_empty_connection_backup(network_tasks.snapshot_create)
         self._test_empty_network_backup(network_tasks.snapshot_create)
 
@@ -367,8 +371,10 @@ def test_snapshot_create(self):
     def test_snapshot_delete(self):
         self._test_no_resource_id(network_tasks.snapshot_delete,
                                   "No network for backup delete")
-        self._test_no_snapshot_name(self._create_ctx(),
-                                    network_tasks.snapshot_delete)
+        self._test_no_snapshot_name(
+            self._create_ctx(),
+            "cloudify_libvirt.network_tasks.libvirt.open",
+            network_tasks.snapshot_delete)
 
         # no such snapshots
         _ctx, connect, network = self._create_fake_network_backup()
@@ -418,7 +424,7 @@ def test_snapshot_delete(self):
         # remove backup
         _ctx, connect, network = self._create_fake_network_backup()
         with mock.patch(
-            "cloudify_libvirt.domain_tasks.libvirt.open",
+            "cloudify_libvirt.network_tasks.libvirt.open",
             mock.Mock(return_value=connect)
         ):
             with mock.patch(
@@ -445,7 +451,9 @@ def test_delete(self):
         self._test_no_resource_id(network_tasks.delete)
         self._test_empty_connection(network_tasks.delete)
         self._test_empty_network(network_tasks.delete)
-        self._test_reused_object(network_tasks.delete)
+        self._test_reused_object(
+            "cloudify_libvirt.network_tasks.libvirt.open",
+            network_tasks.delete)
 
         # delete with error
         _ctx = self._create_ctx()