Add Cinder create_backup volume scenario

Implemented create_backup volume scenario for Cinder

Change-Id: I126f214d6161eb1f3e8eda5bc074f74ef26dcd3a

rally-jobs/rally-mos_neutron.yaml

@@ -274,3 +274,20 @@
       sla:
         failure_rate:
           max: 0
+
+  CinderVolumes.create_volume_backup:
+    -
+      args:
+        size: 1
+        do_delete: True
+      runner:
+        type: "constant"
+        times: 1
+        concurrency: 1
+      context:
+        users:
+          tenants: 1
+          users_per_tenant: 1
+      sla:
+        failure_rate:
+          max: 0

rally-jobs/rally-neutron.yaml

@@ -820,6 +820,42 @@
         failure_rate:
           max: 0
 
+  CinderVolumes.create_volume_backup:
+    -
+      args:
+        size: 1
+        do_delete: True
+      runner:
+        type: "constant"
+        times: 2
+        concurrency: 2
+      context:
+        users:
+          tenants: 1
+          users_per_tenant: 1
+        roles:
+          - "Member"
+      sla:
+        failure_rate:
+          max: 0
+    -
+      args:
+        size: 1
+        do_delete: False
+      runner:
+        type: "constant"
+        times: 2
+        concurrency: 2
+      context:
+        users:
+          tenants: 1
+          users_per_tenant: 1
+        roles:
+          - "Member"
+      sla:
+        failure_rate:
+          max: 0
+
   VMTasks.boot_runcommand_delete:
     -
       args:

rally/benchmark/scenarios/cinder/utils.py

@@ -224,6 +224,38 @@ class CinderScenario(base.Scenario):
             check_interval=CONF.benchmark.cinder_volume_delete_poll_interval
         )
 
+    @base.atomic_action_timer("cinder.create_backup")
+    def _create_backup(self, volume_id, **kwargs):
+        """Create a volume backup of the given volume.
+
+        :param volume_id: The ID of the volume to backup.
+        :param kwargs: Other optional parameters
+        """
+        backup = self.clients("cinder").backups.create(volume_id, **kwargs)
+        return bench_utils.wait_for(
+            backup,
+            is_ready=bench_utils.resource_is("available"),
+            update_resource=bench_utils.get_from_manager(),
+            timeout=CONF.benchmark.cinder_volume_create_timeout,
+            check_interval=CONF.benchmark.cinder_volume_create_poll_interval
+        )
+
+    @base.atomic_action_timer("cinder.delete_backup")
+    def _delete_backup(self, backup):
+        """Delete the given backup.
+
+        Returns when the backup is actually deleted.
+
+        :param backup: backup instance
+        """
+        backup.delete()
+        bench_utils.wait_for_delete(
+            backup,
+            update_resource=bench_utils.get_from_manager(),
+            timeout=CONF.benchmark.cinder_volume_delete_timeout,
+            check_interval=CONF.benchmark.cinder_volume_delete_poll_interval
+        )
+
     def get_random_server(self):
         server_id = random.choice(self.context["tenant"]["servers"])
         return self.clients("nova").servers.get(server_id)

rally/benchmark/scenarios/cinder/volumes.py

@@ -412,3 +412,22 @@ class CinderVolumes(utils.CinderScenario,
         if do_delete:
             self._delete_volume(volume)
             self._delete_image(image)
+
+    @validation.required_cinder_services("cinder-backup")
+    @validation.required_services(consts.Service.CINDER)
+    @validation.required_openstack(users=True)
+    @base.scenario(context={"cleanup": ["cinder"]})
+    def create_volume_backup(self, size, do_delete=True, **kwargs):
+        """Create a volume backup.
+
+        :param size: volume size in GB
+        :param do_delete: if True, a volume and a volume backup will
+                          be deleted after creation.
+        :param kwargs: optional args to create a volume backup
+        """
+        volume = self._create_volume(size, **kwargs)
+        backup = self._create_backup(volume.id, **kwargs)
+
+        if do_delete:
+            self._delete_volume(volume)
+            self._delete_backup(backup)

samples/tasks/scenarios/cinder/create-volume-backup.json

@@ -0,0 +1,22 @@
+{
+    "CinderVolumes.create_volume_backup": [
+        {
+            "args": {
+                "size": 1,
+                "do_delete": true
+            },
+            "runner": {
+                "type": "constant",
+                "times": 2,
+                "concurrency": 1
+            },
+            "context": {
+                "users": {
+                    "tenants": 1,
+                    "users_per_tenant": 1
+                },
+                "roles": ["Member"]
+            }
+        }
+    ]
+}

samples/tasks/scenarios/cinder/create-volume-backup.yaml

@@ -0,0 +1,16 @@
+---
+  CinderVolumes.create_volume_backup:
+    -
+      args:
+        size: 1
+        do_delete: True
+      runner:
+        type: "constant"
+        times: 2
+        concurrency: 1
+      context:
+        users:
+          tenants: 1
+          users_per_tenant: 1
+        roles:
+          - "Member"

tests/unit/benchmark/scenarios/cinder/test_utils.py

@@ -205,6 +205,38 @@ class CinderScenarioTestCase(test.TestCase):
         self._test_atomic_action_timer(self.scenario.atomic_actions(),
                                        "cinder.delete_snapshot")
 
+    @mock.patch(CINDER_UTILS + ".CinderScenario.clients")
+    def test__create_backup(self, mock_clients):
+        backup = mock.Mock()
+        mock_clients("cinder").backups.create.return_value = backup
+
+        return_backup = self.scenario._create_backup("uuid")
+
+        self.wait_for.mock.assert_called_once_with(
+            backup,
+            is_ready=self.res_is.mock(),
+            update_resource=self.gfm(),
+            timeout=cfg.CONF.benchmark.cinder_volume_create_timeout,
+            check_interval=cfg.CONF.benchmark
+            .cinder_volume_create_poll_interval)
+        self.res_is.mock.assert_has_calls([mock.call("available")])
+        self.assertEqual(self.wait_for.mock(), return_backup)
+        self._test_atomic_action_timer(self.scenario.atomic_actions(),
+                                       "cinder.create_backup")
+
+    def test__delete_backup(self):
+        backup = mock.Mock()
+        self.scenario._delete_backup(backup)
+        backup.delete.assert_called_once_with()
+        self.wait_for_delete.mock.assert_called_once_with(
+            backup,
+            update_resource=self.gfm(),
+            timeout=cfg.CONF.benchmark.cinder_volume_create_timeout,
+            check_interval=cfg.CONF.benchmark
+            .cinder_volume_create_poll_interval)
+        self._test_atomic_action_timer(self.scenario.atomic_actions(),
+                                       "cinder.delete_backup")
+
     def test__get_random_server(self):
         servers = [1, 2, 3]
         context = {"user": {"tenant_id": "fake"},

tests/unit/benchmark/scenarios/cinder/test_volumes.py

@@ -362,3 +362,37 @@ class CinderServersTestCase(test.TestCase):
 
         scenario._delete_volume.assert_has_calls(vol_delete_calls)
         scenario._delete_snapshot.assert_has_calls(snap_delete_calls)
+
+    def test_create_volume_backup(self):
+        fake_volume = mock.MagicMock()
+        fake_backup = mock.MagicMock()
+        scenario = volumes.CinderVolumes()
+
+        scenario._create_volume = mock.MagicMock(return_value=fake_volume)
+        scenario._create_backup = mock.MagicMock(return_value=fake_backup)
+        scenario._delete_volume = mock.MagicMock()
+        scenario._delete_backup = mock.MagicMock()
+
+        scenario.create_volume_backup(1, do_delete=True, fakearg="f")
+        scenario._create_volume.assert_called_once_with(1, fakearg="f")
+        scenario._create_backup.assert_called_once_with(fake_volume.id,
+                                                        fakearg="f")
+        scenario._delete_volume.assert_called_once_with(fake_volume)
+        scenario._delete_backup.assert_called_once_with(fake_backup)
+
+    def test_create_volume_backup_no_delete(self):
+        fake_volume = mock.MagicMock()
+        fake_backup = mock.MagicMock()
+        scenario = volumes.CinderVolumes()
+
+        scenario._create_volume = mock.MagicMock(return_value=fake_volume)
+        scenario._create_backup = mock.MagicMock(return_value=fake_backup)
+        scenario._delete_volume = mock.MagicMock()
+        scenario._delete_backup = mock.MagicMock()
+
+        scenario.create_volume_backup(1, do_delete=False, fakearg="f")
+        scenario._create_volume.assert_called_once_with(1, fakearg="f")
+        scenario._create_backup.assert_called_once_with(fake_volume.id,
+                                                        fakearg="f")
+        self.assertFalse(scenario._delete_volume.called)
+        self.assertFalse(scenario._delete_backup.called)