From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([208.118.235.92]:49939) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1UccoI-00086k-0j for qemu-devel@nongnu.org; Wed, 15 May 2013 10:36:13 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1UccoB-000084-39 for qemu-devel@nongnu.org; Wed, 15 May 2013 10:36:05 -0400 Received: from mx1.redhat.com ([209.132.183.28]:35252) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1UccoA-00007w-PP for qemu-devel@nongnu.org; Wed, 15 May 2013 10:35:59 -0400 From: Stefan Hajnoczi Date: Wed, 15 May 2013 16:34:32 +0200 Message-Id: <1368628476-19622-5-git-send-email-stefanha@redhat.com> In-Reply-To: <1368628476-19622-1-git-send-email-stefanha@redhat.com> References: <1368628476-19622-1-git-send-email-stefanha@redhat.com> Subject: [Qemu-devel] [PATCH v3 4/8] qemu-iotests: add 055 drive-backup test case List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel@nongnu.org Cc: Kevin Wolf , Fam Zheng , dietmar@proxmox.com, imain@redhat.com, Stefan Hajnoczi , Paolo Bonzini , xiawenc@linux.vnet.ibm.com Testing drive-backup is similar to image streaming and drive mirroring. This test case is based on 041. Signed-off-by: Stefan Hajnoczi --- tests/qemu-iotests/055 | 230 +++++++++++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/055.out | 5 + tests/qemu-iotests/group | 1 + 3 files changed, 236 insertions(+) create mode 100755 tests/qemu-iotests/055 create mode 100644 tests/qemu-iotests/055.out diff --git a/tests/qemu-iotests/055 b/tests/qemu-iotests/055 new file mode 100755 index 0000000..bc2eebf --- /dev/null +++ b/tests/qemu-iotests/055 @@ -0,0 +1,230 @@ +#!/usr/bin/env python +# +# Tests for drive-backup +# +# Copyright (C) 2013 Red Hat, Inc. +# +# Based on 041. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . +# + +import time +import os +import iotests +from iotests import qemu_img, qemu_io + +test_img = os.path.join(iotests.test_dir, 'test.img') +target_img = os.path.join(iotests.test_dir, 'target.img') + +class DriveBackupTestCase(iotests.QMPTestCase): + '''Abstract base class for drive-backup test cases''' + + def assert_no_active_backups(self): + result = self.vm.qmp('query-block-jobs') + self.assert_qmp(result, 'return', []) + + def cancel_and_wait(self, drive='drive0'): + '''Cancel a block job and wait for it to finish''' + result = self.vm.qmp('block-job-cancel', device=drive) + self.assert_qmp(result, 'return', {}) + + cancelled = False + while not cancelled: + for event in self.vm.get_qmp_events(wait=True): + if event['event'] == 'BLOCK_JOB_COMPLETED' or \ + event['event'] == 'BLOCK_JOB_CANCELLED': + self.assert_qmp(event, 'data/type', 'backup') + self.assert_qmp(event, 'data/device', drive) + cancelled = True + + self.assert_no_active_backups() + + def complete_and_wait(self): + completed = False + while not completed: + for event in self.vm.get_qmp_events(wait=True): + if event['event'] == 'BLOCK_JOB_COMPLETED': + self.assert_qmp(event, 'data/type', 'backup') + self.assert_qmp(event, 'data/device', 'drive0') + self.assert_qmp(event, 'data/offset', self.image_len) + self.assert_qmp(event, 'data/len', self.image_len) + completed = True + self.assert_no_active_backups() + + def compare_images(self, img1, img2): + try: + qemu_img('convert', '-f', iotests.imgfmt, '-O', 'raw', img1, img1 + '.raw') + qemu_img('convert', '-f', iotests.imgfmt, '-O', 'raw', img2, img2 + '.raw') + file1 = open(img1 + '.raw', 'r') + file2 = open(img2 + '.raw', 'r') + return file1.read() == file2.read() + finally: + if file1 is not None: + file1.close() + if file2 is not None: + file2.close() + try: + os.remove(img1 + '.raw') + except OSError: + pass + try: + os.remove(img2 + '.raw') + except OSError: + pass + +class TestSingleDrive(DriveBackupTestCase): + image_len = 120 * 1024 * 1024 # MB + + def setUp(self): + qemu_img('create', '-f', iotests.imgfmt, test_img, str(TestSingleDrive.image_len)) + self.vm = iotests.VM().add_drive(test_img) + self.vm.launch() + + def tearDown(self): + self.vm.shutdown() + os.remove(test_img) + try: + os.remove(target_img) + except OSError: + pass + + def test_complete(self): + self.assert_no_active_backups() + + result = self.vm.qmp('drive-backup', device='drive0', + target=target_img) + self.assert_qmp(result, 'return', {}) + + self.complete_and_wait() + self.vm.shutdown() + self.assertTrue(self.compare_images(test_img, target_img), + 'target image does not match source after backup') + + def test_cancel(self): + self.assert_no_active_backups() + + result = self.vm.qmp('drive-backup', device='drive0', + target=target_img) + self.assert_qmp(result, 'return', {}) + + self.cancel_and_wait() + + def test_pause(self): + self.assert_no_active_backups() + + result = self.vm.qmp('drive-backup', device='drive0', + target=target_img) + self.assert_qmp(result, 'return', {}) + + result = self.vm.qmp('block-job-pause', device='drive0') + self.assert_qmp(result, 'return', {}) + + time.sleep(1) + result = self.vm.qmp('query-block-jobs') + offset = self.dictpath(result, 'return[0]/offset') + + time.sleep(1) + result = self.vm.qmp('query-block-jobs') + self.assert_qmp(result, 'return[0]/offset', offset) + + result = self.vm.qmp('block-job-resume', device='drive0') + self.assert_qmp(result, 'return', {}) + + self.complete_and_wait() + self.vm.shutdown() + self.assertTrue(self.compare_images(test_img, target_img), + 'target image does not match source after backup') + + def test_medium_not_found(self): + result = self.vm.qmp('drive-backup', device='ide1-cd0', + target=target_img) + self.assert_qmp(result, 'error/class', 'GenericError') + + def test_image_not_found(self): + result = self.vm.qmp('drive-backup', device='drive0', + mode='existing', target=target_img) + self.assert_qmp(result, 'error/class', 'GenericError') + + def test_device_not_found(self): + result = self.vm.qmp('drive-backup', device='nonexistent', + target=target_img) + self.assert_qmp(result, 'error/class', 'DeviceNotFound') + +class TestSetSpeed(DriveBackupTestCase): + image_len = 80 * 1024 * 1024 # MB + + def setUp(self): + qemu_img('create', '-f', iotests.imgfmt, test_img, str(TestSetSpeed.image_len)) + self.vm = iotests.VM().add_drive(test_img) + self.vm.launch() + + def tearDown(self): + self.vm.shutdown() + os.remove(test_img) + os.remove(target_img) + + def test_set_speed(self): + self.assert_no_active_backups() + + result = self.vm.qmp('drive-backup', device='drive0', + target=target_img) + self.assert_qmp(result, 'return', {}) + + # Default speed is 0 + result = self.vm.qmp('query-block-jobs') + self.assert_qmp(result, 'return[0]/device', 'drive0') + self.assert_qmp(result, 'return[0]/speed', 0) + + result = self.vm.qmp('block-job-set-speed', device='drive0', speed=8 * 1024 * 1024) + self.assert_qmp(result, 'return', {}) + + # Ensure the speed we set was accepted + result = self.vm.qmp('query-block-jobs') + self.assert_qmp(result, 'return[0]/device', 'drive0') + self.assert_qmp(result, 'return[0]/speed', 8 * 1024 * 1024) + + self.cancel_and_wait() + + # Check setting speed in drive-backup works + result = self.vm.qmp('drive-backup', device='drive0', + target=target_img, speed=4*1024*1024) + self.assert_qmp(result, 'return', {}) + + result = self.vm.qmp('query-block-jobs') + self.assert_qmp(result, 'return[0]/device', 'drive0') + self.assert_qmp(result, 'return[0]/speed', 4 * 1024 * 1024) + + self.cancel_and_wait() + + def test_set_speed_invalid(self): + self.assert_no_active_backups() + + result = self.vm.qmp('drive-backup', device='drive0', + target=target_img, speed=-1) + self.assert_qmp(result, 'error/class', 'GenericError') + + self.assert_no_active_backups() + + result = self.vm.qmp('drive-backup', device='drive0', + target=target_img) + self.assert_qmp(result, 'return', {}) + + result = self.vm.qmp('block-job-set-speed', device='drive0', speed=-1) + self.assert_qmp(result, 'error/class', 'GenericError') + + self.cancel_and_wait() + +if __name__ == '__main__': + iotests.main(supported_fmts=['raw', 'qcow2']) diff --git a/tests/qemu-iotests/055.out b/tests/qemu-iotests/055.out new file mode 100644 index 0000000..594c16f --- /dev/null +++ b/tests/qemu-iotests/055.out @@ -0,0 +1,5 @@ +........ +---------------------------------------------------------------------- +Ran 8 tests + +OK diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group index 387b050..e5762f9 100644 --- a/tests/qemu-iotests/group +++ b/tests/qemu-iotests/group @@ -61,3 +61,4 @@ 052 rw auto backing 053 rw auto 054 rw auto +055 rw auto -- 1.8.1.4