3 # Tests for drive-backup
5 # Copyright (C) 2013 Red Hat, Inc.
9 # This program is free software; you can redistribute it and/or modify
10 # it under the terms of the GNU General Public License as published by
11 # the Free Software Foundation; either version 2 of the License, or
12 # (at your option) any later version.
14 # This program is distributed in the hope that it will be useful,
15 # but WITHOUT ANY WARRANTY; without even the implied warranty of
16 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 # GNU General Public License for more details.
19 # You should have received a copy of the GNU General Public License
20 # along with this program. If not, see <http://www.gnu.org/licenses/>.
26 from iotests
import qemu_img
, qemu_io
28 test_img
= os
.path
.join(iotests
.test_dir
, 'test.img')
29 target_img
= os
.path
.join(iotests
.test_dir
, 'target.img')
31 class TestSingleDrive(iotests
.QMPTestCase
):
32 image_len
= 64 * 1024 * 1024 # MB
35 # Write data to the image so we can compare later
36 qemu_img('create', '-f', iotests
.imgfmt
, test_img
, str(TestSingleDrive
.image_len
))
37 qemu_io('-c', 'write -P0x5d 0 64k', test_img
)
38 qemu_io('-c', 'write -P0xd5 1M 32k', test_img
)
39 qemu_io('-c', 'write -P0xdc 32M 124k', test_img
)
40 qemu_io('-c', 'write -P0xdc 67043328 64k', test_img
)
42 self
.vm
= iotests
.VM().add_drive(test_img
)
53 def test_cancel(self
):
54 self
.assert_no_active_block_jobs()
56 result
= self
.vm
.qmp('drive-backup', device
='drive0',
58 self
.assert_qmp(result
, 'return', {})
60 event
= self
.cancel_and_wait()
61 self
.assert_qmp(event
, 'data/type', 'backup')
64 self
.assert_no_active_block_jobs()
66 result
= self
.vm
.qmp('drive-backup', device
='drive0',
68 self
.assert_qmp(result
, 'return', {})
70 result
= self
.vm
.qmp('block-job-pause', device
='drive0')
71 self
.assert_qmp(result
, 'return', {})
74 result
= self
.vm
.qmp('query-block-jobs')
75 offset
= self
.dictpath(result
, 'return[0]/offset')
78 result
= self
.vm
.qmp('query-block-jobs')
79 self
.assert_qmp(result
, 'return[0]/offset', offset
)
81 result
= self
.vm
.qmp('block-job-resume', device
='drive0')
82 self
.assert_qmp(result
, 'return', {})
84 self
.wait_until_completed()
87 self
.assertTrue(iotests
.compare_images(test_img
, target_img
),
88 'target image does not match source after backup')
90 def test_medium_not_found(self
):
91 result
= self
.vm
.qmp('drive-backup', device
='ide1-cd0',
93 self
.assert_qmp(result
, 'error/class', 'GenericError')
95 def test_image_not_found(self
):
96 result
= self
.vm
.qmp('drive-backup', device
='drive0',
97 mode
='existing', target
=target_img
)
98 self
.assert_qmp(result
, 'error/class', 'GenericError')
100 def test_device_not_found(self
):
101 result
= self
.vm
.qmp('drive-backup', device
='nonexistent',
103 self
.assert_qmp(result
, 'error/class', 'DeviceNotFound')
105 class TestSetSpeed(iotests
.QMPTestCase
):
106 image_len
= 80 * 1024 * 1024 # MB
109 qemu_img('create', '-f', iotests
.imgfmt
, test_img
, str(TestSetSpeed
.image_len
))
110 self
.vm
= iotests
.VM().add_drive(test_img
)
116 os
.remove(target_img
)
118 def test_set_speed(self
):
119 self
.assert_no_active_block_jobs()
121 result
= self
.vm
.qmp('drive-backup', device
='drive0',
123 self
.assert_qmp(result
, 'return', {})
126 result
= self
.vm
.qmp('query-block-jobs')
127 self
.assert_qmp(result
, 'return[0]/device', 'drive0')
128 self
.assert_qmp(result
, 'return[0]/speed', 0)
130 result
= self
.vm
.qmp('block-job-set-speed', device
='drive0', speed
=8 * 1024 * 1024)
131 self
.assert_qmp(result
, 'return', {})
133 # Ensure the speed we set was accepted
134 result
= self
.vm
.qmp('query-block-jobs')
135 self
.assert_qmp(result
, 'return[0]/device', 'drive0')
136 self
.assert_qmp(result
, 'return[0]/speed', 8 * 1024 * 1024)
138 event
= self
.cancel_and_wait()
139 self
.assert_qmp(event
, 'data/type', 'backup')
141 # Check setting speed in drive-backup works
142 result
= self
.vm
.qmp('drive-backup', device
='drive0',
143 target
=target_img
, speed
=4*1024*1024)
144 self
.assert_qmp(result
, 'return', {})
146 result
= self
.vm
.qmp('query-block-jobs')
147 self
.assert_qmp(result
, 'return[0]/device', 'drive0')
148 self
.assert_qmp(result
, 'return[0]/speed', 4 * 1024 * 1024)
150 event
= self
.cancel_and_wait()
151 self
.assert_qmp(event
, 'data/type', 'backup')
153 def test_set_speed_invalid(self
):
154 self
.assert_no_active_block_jobs()
156 result
= self
.vm
.qmp('drive-backup', device
='drive0',
157 target
=target_img
, speed
=-1)
158 self
.assert_qmp(result
, 'error/class', 'GenericError')
160 self
.assert_no_active_block_jobs()
162 result
= self
.vm
.qmp('drive-backup', device
='drive0',
164 self
.assert_qmp(result
, 'return', {})
166 result
= self
.vm
.qmp('block-job-set-speed', device
='drive0', speed
=-1)
167 self
.assert_qmp(result
, 'error/class', 'GenericError')
169 event
= self
.cancel_and_wait()
170 self
.assert_qmp(event
, 'data/type', 'backup')
172 class TestSingleTransaction(iotests
.QMPTestCase
):
173 image_len
= 64 * 1024 * 1024 # MB
176 qemu_img('create', '-f', iotests
.imgfmt
, test_img
, str(TestSingleTransaction
.image_len
))
177 qemu_io('-c', 'write -P0x5d 0 64k', test_img
)
178 qemu_io('-c', 'write -P0xd5 1M 32k', test_img
)
179 qemu_io('-c', 'write -P0xdc 32M 124k', test_img
)
180 qemu_io('-c', 'write -P0xdc 67043328 64k', test_img
)
182 self
.vm
= iotests
.VM().add_drive(test_img
)
189 os
.remove(target_img
)
193 def test_cancel(self
):
194 self
.assert_no_active_block_jobs()
196 result
= self
.vm
.qmp('transaction', actions
=[{
197 'type': 'drive-backup',
198 'data': { 'device': 'drive0',
199 'target': target_img
},
202 self
.assert_qmp(result
, 'return', {})
204 event
= self
.cancel_and_wait()
205 self
.assert_qmp(event
, 'data/type', 'backup')
207 def test_pause(self
):
208 self
.assert_no_active_block_jobs()
210 result
= self
.vm
.qmp('transaction', actions
=[{
211 'type': 'drive-backup',
212 'data': { 'device': 'drive0',
213 'target': target_img
},
216 self
.assert_qmp(result
, 'return', {})
218 result
= self
.vm
.qmp('block-job-pause', device
='drive0')
219 self
.assert_qmp(result
, 'return', {})
222 result
= self
.vm
.qmp('query-block-jobs')
223 offset
= self
.dictpath(result
, 'return[0]/offset')
226 result
= self
.vm
.qmp('query-block-jobs')
227 self
.assert_qmp(result
, 'return[0]/offset', offset
)
229 result
= self
.vm
.qmp('block-job-resume', device
='drive0')
230 self
.assert_qmp(result
, 'return', {})
232 self
.wait_until_completed()
235 self
.assertTrue(iotests
.compare_images(test_img
, target_img
),
236 'target image does not match source after backup')
238 def test_medium_not_found(self
):
239 result
= self
.vm
.qmp('transaction', actions
=[{
240 'type': 'drive-backup',
241 'data': { 'device': 'ide1-cd0',
242 'target': target_img
},
245 self
.assert_qmp(result
, 'error/class', 'GenericError')
247 def test_image_not_found(self
):
248 result
= self
.vm
.qmp('transaction', actions
=[{
249 'type': 'drive-backup',
250 'data': { 'device': 'drive0',
252 'target': target_img
},
255 self
.assert_qmp(result
, 'error/class', 'GenericError')
257 def test_device_not_found(self
):
258 result
= self
.vm
.qmp('transaction', actions
=[{
259 'type': 'drive-backup',
260 'data': { 'device': 'nonexistent',
262 'target': target_img
},
265 self
.assert_qmp(result
, 'error/class', 'DeviceNotFound')
267 def test_abort(self
):
268 result
= self
.vm
.qmp('transaction', actions
=[{
269 'type': 'drive-backup',
270 'data': { 'device': 'nonexistent',
272 'target': target_img
},
278 self
.assert_qmp(result
, 'error/class', 'GenericError')
279 self
.assert_no_active_block_jobs()
281 if __name__
== '__main__':
282 iotests
.main(supported_fmts
=['raw', 'qcow2'])