Coverage for manila/tests/share/drivers/netapp/dataontap/cluster_mode/test_data_motion.py: 100%

1# Copyright (c) 2015 Alex Meade. All rights reserved. 

2# 

3# Licensed under the Apache License, Version 2.0 (the "License"); you may 

4# not use this file except in compliance with the License. You may obtain 

5# a copy of the License at 

6# 

7# http://www.apache.org/licenses/LICENSE-2.0 

8# 

9# Unless required by applicable law or agreed to in writing, software 

10# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 

11# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 

12# License for the specific language governing permissions and limitations 

13# under the License. 

14 

15import copy 

16import time 

17from unittest import mock 

18 

19import ddt 

20from oslo_config import cfg 

21 

22from manila import exception 

23from manila.share import configuration 

24from manila.share import driver 

25from manila.share.drivers.netapp.dataontap.client import api as netapp_api 

26from manila.share.drivers.netapp.dataontap.client import client_cmode 

27from manila.share.drivers.netapp.dataontap.cluster_mode import data_motion 

28from manila.share.drivers.netapp import options as na_opts 

29from manila.share.drivers.netapp import utils as na_utils 

30from manila.share import utils as share_utils 

31from manila import test 

32from manila.tests.share.drivers.netapp.dataontap import fakes as fake 

33from manila.tests.share.drivers.netapp import fakes as na_fakes 

34 

35 

36CONF = cfg.CONF 

37 

38 

39@ddt.ddt 

40class NetAppCDOTDataMotionTestCase(test.TestCase): 

41 

42 def setUp(self): 

43 super(NetAppCDOTDataMotionTestCase, self).setUp() 

44 self.backend = 'backend1' 

45 self.force_rest_client = False 

46 self.mock_cmode_client = self.mock_object(client_cmode, 

47 "NetAppCmodeClient", 

48 mock.Mock()) 

49 self.config = configuration.Configuration(driver.share_opts, 

50 config_group=self.backend) 

51 self.config.append_config_values(na_opts.netapp_cluster_opts) 

52 self.config.append_config_values(na_opts.netapp_connection_opts) 

53 self.config.append_config_values(na_opts.netapp_basicauth_opts) 

54 self.config.append_config_values(na_opts.netapp_certificateauth_opts) 

55 self.config.append_config_values(na_opts.netapp_transport_opts) 

56 self.config.append_config_values(na_opts.netapp_support_opts) 

57 self.config.append_config_values(na_opts.netapp_provisioning_opts) 

58 self.config.append_config_values(na_opts.netapp_data_motion_opts) 

59 CONF.set_override("share_backend_name", self.backend, 

60 group=self.backend) 

61 CONF.set_override("netapp_transport_type", "https", 

62 group=self.backend) 

63 CONF.set_override("netapp_login", "fake_user", 

64 group=self.backend) 

65 CONF.set_override("netapp_password", "fake_password", 

66 group=self.backend) 

67 CONF.set_override("netapp_server_hostname", "fake.hostname", 

68 group=self.backend) 

69 CONF.set_override("netapp_server_port", 8866, 

70 group=self.backend) 

71 CONF.set_override("netapp_ssl_cert_path", "/etc/ssl/certs", 

72 group=self.backend) 

73 CONF.set_override("netapp_private_key_file", "/fake_private_key.pem", 

74 group=self.backend) 

75 CONF.set_override("netapp_certificate_file", "/fake_cert.pem", 

76 group=self.backend) 

77 CONF.set_override("netapp_ca_certificate_file", "/fake_ca_cert.crt", 

78 group=self.backend) 

79 CONF.set_override("netapp_certificate_host_validation", False, 

80 group=self.backend) 

81 

82 def test_get_client_for_backend(self): 

83 self.mock_object(data_motion, "get_backend_configuration", 

84 mock.Mock(return_value=self.config)) 

85 

86 data_motion.get_client_for_backend(self.backend, 

87 self.force_rest_client) 

88 

89 self.mock_cmode_client.assert_called_once_with( 

90 hostname='fake.hostname', password='fake_password', 

91 username='fake_user', transport_type='https', port=8866, 

92 ssl_cert_path='/etc/ssl/certs', trace=mock.ANY, vserver=None, 

93 private_key_file='/fake_private_key.pem', 

94 certificate_file='/fake_cert.pem', 

95 ca_certificate_file='/fake_ca_cert.crt', 

96 certificate_host_validation=False) 

97 

98 def test_get_client_for_backend_with_vserver(self): 

99 self.mock_object(data_motion, "get_backend_configuration", 

100 mock.Mock(return_value=self.config)) 

101 

102 CONF.set_override("netapp_vserver", 'fake_vserver', 

103 group=self.backend) 

104 

105 data_motion.get_client_for_backend(self.backend) 

106 

107 self.mock_cmode_client.assert_called_once_with( 

108 hostname='fake.hostname', password='fake_password', 

109 username='fake_user', transport_type='https', port=8866, 

110 ssl_cert_path='/etc/ssl/certs', trace=mock.ANY, 

111 vserver='fake_vserver', 

112 private_key_file='/fake_private_key.pem', 

113 certificate_file='/fake_cert.pem', 

114 ca_certificate_file='/fake_ca_cert.crt', 

115 certificate_host_validation=False) 

116 

117 def test_get_client_for_host(self): 

118 mock_extract_host = self.mock_object( 

119 share_utils, 'extract_host', 

120 mock.Mock(return_value=fake.BACKEND_NAME)) 

121 mock_get_client = self.mock_object( 

122 data_motion, 'get_client_for_backend', 

123 mock.Mock(return_value=self.mock_cmode_client)) 

124 

125 returned_client = data_motion.get_client_for_host( 

126 fake.HOST_NAME) 

127 

128 mock_extract_host.assert_called_once_with( 

129 fake.HOST_NAME, level='backend_name') 

130 mock_get_client.assert_called_once_with(fake.BACKEND_NAME) 

131 self.assertEqual(returned_client, self.mock_cmode_client) 

132 

133 def test_get_config_for_backend(self): 

134 self.mock_object(data_motion, "CONF") 

135 

136 CONF.set_override("netapp_vserver", 'fake_vserver', 

137 group=self.backend) 

138 

139 CONF.set_override("driver_handles_share_servers", False, 

140 group=self.backend) 

141 

142 config = data_motion.get_backend_configuration(self.backend) 

143 

144 self.assertEqual('fake_vserver', config.netapp_vserver) 

145 

146 def test_get_config_for_backend_different_backend_name(self): 

147 self.mock_object(data_motion, "CONF") 

148 CONF.set_override("netapp_vserver", 'fake_vserver', 

149 group=self.backend) 

150 CONF.set_override("share_backend_name", "fake_backend_name", 

151 group=self.backend) 

152 

153 CONF.set_override("driver_handles_share_servers", False, 

154 group=self.backend) 

155 

156 config = data_motion.get_backend_configuration(self.backend) 

157 

158 self.assertEqual('fake_vserver', config.netapp_vserver) 

159 self.assertEqual('fake_backend_name', config.share_backend_name) 

160 

161 @ddt.data([], ['fake_backend1', 'fake_backend2']) 

162 def test_get_config_for_backend_not_configured(self, conf_sections): 

163 self.mock_object(data_motion, "CONF") 

164 

165 self.assertRaises(exception.BadConfigurationException, 

166 data_motion.get_backend_configuration, 

167 self.backend) 

168 

169 

170@ddt.ddt 

171class NetAppCDOTDataMotionSessionTestCase(test.TestCase): 

172 

173 def setUp(self): 

174 super(NetAppCDOTDataMotionSessionTestCase, self).setUp() 

175 

176 self.sleep_patcher = mock.patch.object(time, 'sleep', lambda s: None) 

177 self.sleep_patcher.start() 

178 self.addCleanup(self.sleep_patcher.stop) 

179 

180 self.source_backend = 'backend1' 

181 self.dest_backend = 'backend2' 

182 

183 config = configuration.Configuration(driver.share_opts, 

184 config_group=self.source_backend) 

185 config.append_config_values(na_opts.netapp_cluster_opts) 

186 config.append_config_values(na_opts.netapp_connection_opts) 

187 config.append_config_values(na_opts.netapp_basicauth_opts) 

188 config.append_config_values(na_opts.netapp_certificateauth_opts) 

189 config.append_config_values(na_opts.netapp_transport_opts) 

190 config.append_config_values(na_opts.netapp_support_opts) 

191 config.append_config_values(na_opts.netapp_provisioning_opts) 

192 config.append_config_values(na_opts.netapp_data_motion_opts) 

193 

194 self.mock_object(data_motion, "get_backend_configuration", 

195 mock.Mock(return_value=config)) 

196 

197 self.mock_cmode_client = self.mock_object(client_cmode, 

198 "NetAppCmodeClient", 

199 mock.Mock()) 

200 self.dm_session = data_motion.DataMotionSession() 

201 self.fake_src_share = copy.deepcopy(fake.SHARE) 

202 self.fake_src_share_server = copy.deepcopy(fake.SHARE_SERVER) 

203 self.source_vserver = 'source_vserver' 

204 self.source_backend_name = ( 

205 self.fake_src_share_server['host'].split('@')[1]) 

206 self.fake_src_share_server['backend_details']['vserver_name'] = ( 

207 self.source_vserver 

208 ) 

209 self.fake_src_share['share_server'] = self.fake_src_share_server 

210 self.fake_src_share['id'] = 'c02d497a-236c-4852-812a-0d39373e312a' 

211 self.fake_src_vol_name = 'share_c02d497a_236c_4852_812a_0d39373e312a' 

212 self.fake_dest_share = copy.deepcopy(fake.SHARE) 

213 self.fake_dest_share_server = copy.deepcopy(fake.SHARE_SERVER_2) 

214 self.dest_vserver = 'dest_vserver' 

215 self.dest_backend_name = ( 

216 self.fake_dest_share_server['host'].split('@')[1]) 

217 self.fake_dest_share_server['backend_details']['vserver_name'] = ( 

218 self.dest_vserver 

219 ) 

220 self.fake_dest_share['share_server'] = self.fake_dest_share_server 

221 self.fake_dest_share['id'] = '34fbaf57-745d-460f-8270-3378c2945e30' 

222 self.fake_dest_vol_name = 'share_34fbaf57_745d_460f_8270_3378c2945e30' 

223 

224 self.mock_src_client = mock.Mock() 

225 self.mock_dest_client = mock.Mock() 

226 self.mock_object(data_motion, 'get_client_for_backend', 

227 mock.Mock(side_effect=[self.mock_dest_client, 

228 self.mock_src_client])) 

229 self.mock_object(self.dm_session, 'get_client_and_vserver_name', 

230 mock.Mock(side_effect=[ 

231 (self.mock_src_client, self.source_vserver), 

232 (self.mock_dest_client, self.dest_vserver)])) 

233 

234 def test_get_client_and_vserver_name(self): 

235 dm_session = data_motion.DataMotionSession() 

236 client = mock.Mock() 

237 self.mock_object(data_motion, 'get_client_for_backend', 

238 mock.Mock(return_value=client)) 

239 

240 result = dm_session.get_client_and_vserver_name(fake.SHARE_SERVER) 

241 expected = (client, 

242 fake.SHARE_SERVER['backend_details']['vserver_name']) 

243 

244 self.assertEqual(expected, result) 

245 data_motion.get_client_for_backend.assert_called_once_with( 

246 fake.BACKEND_NAME, vserver_name=fake.VSERVER1 

247 ) 

248 

249 @ddt.data(True, False) 

250 def test_create_snapmirror_mount(self, mount): 

251 mock_dest_client = mock.Mock() 

252 self.mock_object(data_motion, 'get_client_for_backend', 

253 mock.Mock(return_value=mock_dest_client)) 

254 self.mock_object(self.dm_session, 'wait_for_mount_replica') 

255 mock_backend_config = na_fakes.create_configuration() 

256 mock_backend_config.netapp_mount_replica_timeout = 30 

257 self.mock_object(data_motion, 'get_backend_configuration', 

258 mock.Mock(return_value=mock_backend_config)) 

259 

260 self.dm_session.create_snapmirror(self.fake_src_share, 

261 self.fake_dest_share, 

262 'data_protection', mount=mount) 

263 

264 mock_dest_client.create_snapmirror_vol.assert_called_once_with( 

265 mock.ANY, self.fake_src_vol_name, mock.ANY, 

266 self.fake_dest_vol_name, 'data_protection', schedule='hourly' 

267 ) 

268 mock_dest_client.initialize_snapmirror_vol.assert_called_once_with( 

269 mock.ANY, self.fake_src_vol_name, mock.ANY, 

270 self.fake_dest_vol_name 

271 ) 

272 if mount: 

273 self.dm_session.wait_for_mount_replica.assert_called_once_with( 

274 mock_dest_client, self.fake_dest_vol_name, timeout=30) 

275 else: 

276 self.dm_session.wait_for_mount_replica.assert_not_called() 

277 

278 def test_create_snapmirror_svm(self): 

279 mock_dest_client = mock.Mock() 

280 self.mock_object(self.dm_session, 'get_client_and_vserver_name', 

281 mock.Mock(return_value=(mock_dest_client, 

282 self.dest_vserver))) 

283 self.mock_object(self.dm_session, 'get_vserver_from_share_server', 

284 mock.Mock(return_value=self.source_vserver)) 

285 policy_name = 'policy_' + self.dest_vserver 

286 get_snapmirro_policy_name = self.mock_object( 

287 self.dm_session, '_get_backend_snapmirror_policy_name_svm', 

288 mock.Mock(return_value=policy_name)) 

289 

290 self.dm_session.create_snapmirror_svm(self.fake_src_share_server, 

291 self.fake_dest_share_server) 

292 

293 self.dm_session.get_client_and_vserver_name.assert_called_once_with( 

294 self.fake_dest_share_server 

295 ) 

296 self.dm_session.get_vserver_from_share_server.assert_called_once_with( 

297 self.fake_src_share_server 

298 ) 

299 get_snapmirro_policy_name.assert_called_once_with( 

300 self.fake_dest_share_server['id'], self.dest_backend_name 

301 ) 

302 mock_dest_client.create_snapmirror_policy.assert_called_once_with( 

303 policy_name 

304 ) 

305 mock_dest_client.create_snapmirror_svm.assert_called_once_with( 

306 self.source_vserver, self.dest_vserver, 

307 policy=policy_name, schedule='hourly' 

308 ) 

309 mock_dest_client.initialize_snapmirror_svm.assert_called_once_with( 

310 self.source_vserver, self.dest_vserver 

311 ) 

312 

313 def test_delete_snapmirror(self): 

314 mock_src_client = mock.Mock() 

315 mock_dest_client = mock.Mock() 

316 self.mock_object(data_motion, 'get_client_for_backend', 

317 mock.Mock(side_effect=[mock_dest_client, 

318 mock_src_client])) 

319 mock_backend_config = na_fakes.create_configuration() 

320 mock_backend_config.netapp_snapmirror_release_timeout = 30 

321 self.mock_object(data_motion, 'get_backend_configuration', 

322 mock.Mock(return_value=mock_backend_config)) 

323 mock_wait_for_snapmirror_release_vol = self.mock_object( 

324 self.dm_session, 'wait_for_snapmirror_release_vol') 

325 

326 self.dm_session.delete_snapmirror(self.fake_src_share, 

327 self.fake_dest_share) 

328 

329 mock_dest_client.abort_snapmirror_vol.assert_called_once_with( 

330 mock.ANY, self.fake_src_vol_name, mock.ANY, 

331 self.fake_dest_vol_name, clear_checkpoint=False 

332 ) 

333 mock_dest_client.delete_snapmirror_vol.assert_called_once_with( 

334 mock.ANY, self.fake_src_vol_name, mock.ANY, 

335 self.fake_dest_vol_name 

336 ) 

337 mock_wait_for_snapmirror_release_vol.assert_called_once_with( 

338 self.source_vserver, self.dest_vserver, self.fake_src_vol_name, 

339 self.fake_dest_vol_name, False, mock_src_client, 

340 timeout=30 

341 ) 

342 

343 @ddt.data(True, False) 

344 def test_delete_snapmirror_svm(self, call_release): 

345 self.mock_object(self.dm_session, 'wait_for_snapmirror_release_svm') 

346 mock_backend_config = na_fakes.create_configuration() 

347 mock_backend_config.netapp_snapmirror_release_timeout = 30 

348 self.mock_object(data_motion, 'get_backend_configuration', 

349 mock.Mock(return_value=mock_backend_config)) 

350 

351 self.dm_session.delete_snapmirror_svm(self.fake_src_share_server, 

352 self.fake_dest_share_server, 

353 release=call_release) 

354 

355 self.mock_dest_client.abort_snapmirror_svm.assert_called_once_with( 

356 self.source_vserver, self.dest_vserver 

357 ) 

358 self.mock_dest_client.delete_snapmirror_svm.assert_called_once_with( 

359 self.source_vserver, self.dest_vserver 

360 ) 

361 if call_release: 

362 release_mock = self.dm_session.wait_for_snapmirror_release_svm 

363 release_mock.assert_called_once_with( 

364 self.source_vserver, self.dest_vserver, self.mock_src_client, 

365 timeout=mock_backend_config.netapp_snapmirror_release_timeout 

366 ) 

367 

368 def test_delete_snapmirror_does_not_exist(self): 

369 """Ensure delete succeeds when the snapmirror does not exist.""" 

370 mock_src_client = mock.Mock() 

371 mock_dest_client = mock.Mock() 

372 mock_dest_client.abort_snapmirror_vol.side_effect = ( 

373 netapp_api.NaApiError(code=netapp_api.EAPIERROR)) 

374 self.mock_object(data_motion, 'get_client_for_backend', 

375 mock.Mock(side_effect=[mock_dest_client, 

376 mock_src_client])) 

377 mock_backend_config = na_fakes.create_configuration() 

378 mock_backend_config.netapp_snapmirror_release_timeout = 30 

379 self.mock_object(data_motion, 'get_backend_configuration', 

380 mock.Mock(return_value=mock_backend_config)) 

381 mock_wait_for_snapmirror_release_vol = self.mock_object( 

382 self.dm_session, 'wait_for_snapmirror_release_vol') 

383 

384 self.dm_session.delete_snapmirror(self.fake_src_share, 

385 self.fake_dest_share) 

386 

387 mock_dest_client.abort_snapmirror_vol.assert_called_once_with( 

388 mock.ANY, self.fake_src_vol_name, mock.ANY, 

389 self.fake_dest_vol_name, clear_checkpoint=False 

390 ) 

391 mock_dest_client.delete_snapmirror_vol.assert_called_once_with( 

392 mock.ANY, self.fake_src_vol_name, mock.ANY, 

393 self.fake_dest_vol_name 

394 ) 

395 mock_wait_for_snapmirror_release_vol.assert_called_once_with( 

396 self.source_vserver, self.dest_vserver, self.fake_src_vol_name, 

397 self.fake_dest_vol_name, False, mock_src_client, 

398 timeout=30 

399 ) 

400 

401 def test_delete_snapmirror_svm_does_not_exist(self): 

402 """Ensure delete succeeds when the snapmirror does not exist.""" 

403 self.mock_dest_client.abort_snapmirror_svm.side_effect = ( 

404 netapp_api.NaApiError(code=netapp_api.EAPIERROR)) 

405 self.mock_object(self.dm_session, 'wait_for_snapmirror_release_svm') 

406 mock_backend_config = na_fakes.create_configuration() 

407 mock_backend_config.netapp_snapmirror_release_timeout = 30 

408 self.mock_object(data_motion, 'get_backend_configuration', 

409 mock.Mock(return_value=mock_backend_config)) 

410 

411 self.dm_session.delete_snapmirror_svm(self.fake_src_share_server, 

412 self.fake_dest_share_server) 

413 

414 self.mock_dest_client.abort_snapmirror_svm.assert_called_once_with( 

415 self.source_vserver, self.dest_vserver 

416 ) 

417 self.mock_dest_client.delete_snapmirror_svm.assert_called_once_with( 

418 self.source_vserver, self.dest_vserver 

419 ) 

420 release_mock = self.dm_session.wait_for_snapmirror_release_svm 

421 release_mock.assert_called_once_with( 

422 self.source_vserver, self.dest_vserver, self.mock_src_client, 

423 timeout=mock_backend_config.netapp_snapmirror_release_timeout 

424 ) 

425 

426 def test_delete_snapmirror_error_deleting(self): 

427 """Ensure delete succeeds when the snapmirror does not exist.""" 

428 mock_src_client = mock.Mock() 

429 mock_dest_client = mock.Mock() 

430 mock_dest_client.delete_snapmirror_vol.side_effect = ( 

431 netapp_api.NaApiError(code=netapp_api.ESOURCE_IS_DIFFERENT)) 

432 self.mock_object(data_motion, 'get_client_for_backend', 

433 mock.Mock(side_effect=[mock_dest_client, 

434 mock_src_client])) 

435 mock_backend_config = na_fakes.create_configuration() 

436 mock_backend_config.netapp_snapmirror_release_timeout = 30 

437 self.mock_object(data_motion, 'get_backend_configuration', 

438 mock.Mock(return_value=mock_backend_config)) 

439 mock_wait_for_snapmirror_release_vol = self.mock_object( 

440 self.dm_session, 'wait_for_snapmirror_release_vol') 

441 

442 self.dm_session.delete_snapmirror(self.fake_src_share, 

443 self.fake_dest_share) 

444 

445 mock_dest_client.abort_snapmirror_vol.assert_called_once_with( 

446 mock.ANY, self.fake_src_vol_name, mock.ANY, 

447 self.fake_dest_vol_name, clear_checkpoint=False 

448 ) 

449 mock_dest_client.delete_snapmirror_vol.assert_called_once_with( 

450 mock.ANY, self.fake_src_vol_name, mock.ANY, 

451 self.fake_dest_vol_name 

452 ) 

453 mock_wait_for_snapmirror_release_vol.assert_called_once_with( 

454 self.source_vserver, self.dest_vserver, self.fake_src_vol_name, 

455 self.fake_dest_vol_name, False, mock_src_client, 

456 timeout=30 

457 ) 

458 

459 def test_delete_snapmirror_svm_error_deleting(self): 

460 """Ensure delete succeeds when the snapmirror does not exist.""" 

461 self.mock_dest_client.delete_snapmirror_svm.side_effect = ( 

462 netapp_api.NaApiError(code=netapp_api.ESOURCE_IS_DIFFERENT)) 

463 self.mock_object(self.dm_session, 'wait_for_snapmirror_release_svm') 

464 mock_backend_config = na_fakes.create_configuration() 

465 mock_backend_config.netapp_snapmirror_release_timeout = 30 

466 self.mock_object(data_motion, 'get_backend_configuration', 

467 mock.Mock(return_value=mock_backend_config)) 

468 

469 self.dm_session.delete_snapmirror_svm(self.fake_src_share_server, 

470 self.fake_dest_share_server) 

471 

472 self.mock_dest_client.abort_snapmirror_svm.assert_called_once_with( 

473 self.source_vserver, self.dest_vserver 

474 ) 

475 self.mock_dest_client.delete_snapmirror_svm.assert_called_once_with( 

476 self.source_vserver, self.dest_vserver 

477 ) 

478 release_mock = self.dm_session.wait_for_snapmirror_release_svm 

479 release_mock.assert_called_once_with( 

480 self.source_vserver, self.dest_vserver, self.mock_src_client, 

481 timeout=mock_backend_config.netapp_snapmirror_release_timeout 

482 ) 

483 

484 def test_delete_snapmirror_without_release(self): 

485 mock_src_client = mock.Mock() 

486 mock_dest_client = mock.Mock() 

487 self.mock_object(data_motion, 'get_client_for_backend', 

488 mock.Mock(side_effect=[mock_dest_client, 

489 mock_src_client])) 

490 mock_wait_for_snapmirror_release_vol = self.mock_object( 

491 self.dm_session, 'wait_for_snapmirror_release_vol') 

492 

493 self.dm_session.delete_snapmirror(self.fake_src_share, 

494 self.fake_dest_share, 

495 release=False) 

496 

497 mock_dest_client.abort_snapmirror_vol.assert_called_once_with( 

498 mock.ANY, self.fake_src_vol_name, mock.ANY, 

499 self.fake_dest_vol_name, clear_checkpoint=False 

500 ) 

501 mock_dest_client.delete_snapmirror_vol.assert_called_once_with( 

502 mock.ANY, self.fake_src_vol_name, mock.ANY, 

503 self.fake_dest_vol_name 

504 ) 

505 self.assertFalse(mock_wait_for_snapmirror_release_vol.called) 

506 

507 def test_delete_snapmirror_source_unreachable(self): 

508 mock_dest_client = mock.Mock() 

509 self.mock_object(data_motion, 'get_client_for_backend', 

510 mock.Mock(side_effect=[mock_dest_client, 

511 Exception])) 

512 mock_wait_for_snapmirror_release_vol = self.mock_object( 

513 self.dm_session, 'wait_for_snapmirror_release_vol') 

514 

515 self.dm_session.delete_snapmirror(self.fake_src_share, 

516 self.fake_dest_share) 

517 

518 mock_dest_client.abort_snapmirror_vol.assert_called_once_with( 

519 mock.ANY, self.fake_src_vol_name, mock.ANY, 

520 self.fake_dest_vol_name, clear_checkpoint=False 

521 ) 

522 mock_dest_client.delete_snapmirror_vol.assert_called_once_with( 

523 mock.ANY, self.fake_src_vol_name, mock.ANY, 

524 self.fake_dest_vol_name 

525 ) 

526 self.assertFalse(mock_wait_for_snapmirror_release_vol.called) 

527 

528 def test_break_snapmirror(self): 

529 self.mock_object(self.dm_session, 'quiesce_then_abort') 

530 

531 self.dm_session.break_snapmirror(self.fake_src_share, 

532 self.fake_dest_share) 

533 

534 self.mock_dest_client.break_snapmirror_vol.assert_called_once_with( 

535 self.source_vserver, self.fake_src_vol_name, 

536 self.dest_vserver, self.fake_dest_vol_name) 

537 

538 self.dm_session.quiesce_then_abort.assert_called_once_with( 

539 self.fake_src_share, self.fake_dest_share, 

540 quiesce_wait_time=None) 

541 

542 self.mock_dest_client.mount_volume.assert_called_once_with( 

543 self.fake_dest_vol_name) 

544 

545 def test_break_snapmirror_no_mount(self): 

546 self.mock_object(self.dm_session, 'quiesce_then_abort') 

547 

548 self.dm_session.break_snapmirror(self.fake_src_share, 

549 self.fake_dest_share, 

550 mount=False) 

551 

552 self.mock_dest_client.break_snapmirror_vol.assert_called_once_with( 

553 self.source_vserver, self.fake_src_vol_name, 

554 self.dest_vserver, self.fake_dest_vol_name) 

555 

556 self.dm_session.quiesce_then_abort.assert_called_once_with( 

557 self.fake_src_share, self.fake_dest_share, 

558 quiesce_wait_time=None) 

559 

560 self.assertFalse(self.mock_dest_client.mount_volume.called) 

561 

562 def test_break_snapmirror_wait_for_quiesced(self): 

563 self.mock_object(self.dm_session, 'quiesce_then_abort') 

564 

565 self.dm_session.break_snapmirror(self.fake_src_share, 

566 self.fake_dest_share) 

567 

568 self.dm_session.quiesce_then_abort.assert_called_once_with( 

569 self.fake_src_share, self.fake_dest_share, 

570 quiesce_wait_time=None) 

571 

572 self.mock_dest_client.break_snapmirror_vol.assert_called_once_with( 

573 self.source_vserver, self.fake_src_vol_name, 

574 self.dest_vserver, self.fake_dest_vol_name) 

575 

576 self.mock_dest_client.mount_volume.assert_called_once_with( 

577 self.fake_dest_vol_name) 

578 

579 @ddt.data(None, 2, 30) 

580 def test_quiesce_then_abort_wait_time(self, wait_time): 

581 self.mock_object(time, 'sleep') 

582 mock_get_snapmirrors = mock.Mock( 

583 return_value=[{'relationship-status': "transferring"}]) 

584 self.mock_object(self.mock_dest_client, 'get_snapmirrors', 

585 mock_get_snapmirrors) 

586 mock_backend_config = na_fakes.create_configuration() 

587 mock_backend_config.netapp_snapmirror_quiesce_timeout = 10 

588 self.mock_object(data_motion, 'get_backend_configuration', 

589 mock.Mock(return_value=mock_backend_config)) 

590 

591 self.dm_session.quiesce_then_abort(self.fake_src_share, 

592 self.fake_dest_share, 

593 quiesce_wait_time=wait_time) 

594 

595 self.mock_dest_client.get_snapmirrors.assert_called_with( 

596 source_vserver=self.source_vserver, 

597 dest_vserver=self.dest_vserver, 

598 source_volume=self.fake_src_vol_name, 

599 dest_volume=self.fake_dest_vol_name, 

600 desired_attributes=['relationship-status', 'mirror-state'] 

601 ) 

602 

603 call_count = self.mock_dest_client.get_snapmirrors.call_count 

604 if wait_time: 

605 if wait_time > 5: 

606 self.assertEqual(wait_time / 5, call_count) 

607 else: 

608 self.assertEqual(1, call_count) 

609 else: 

610 self.assertEqual(2, call_count) 

611 

612 def test_quiesce_then_abort_timeout(self): 

613 self.mock_object(time, 'sleep') 

614 mock_get_snapmirrors = mock.Mock( 

615 return_value=[{'relationship-status': "transferring"}]) 

616 self.mock_object(self.mock_dest_client, 'get_snapmirrors', 

617 mock_get_snapmirrors) 

618 mock_backend_config = na_fakes.create_configuration() 

619 mock_backend_config.netapp_snapmirror_quiesce_timeout = 10 

620 self.mock_object(data_motion, 'get_backend_configuration', 

621 mock.Mock(return_value=mock_backend_config)) 

622 

623 self.dm_session.quiesce_then_abort(self.fake_src_share, 

624 self.fake_dest_share) 

625 

626 self.mock_dest_client.get_snapmirrors.assert_called_with( 

627 source_vserver=self.source_vserver, 

628 dest_vserver=self.dest_vserver, 

629 source_volume=self.fake_src_vol_name, 

630 dest_volume=self.fake_dest_vol_name, 

631 desired_attributes=['relationship-status', 'mirror-state'] 

632 ) 

633 self.assertEqual(2, self.mock_dest_client.get_snapmirrors.call_count) 

634 

635 self.mock_dest_client.quiesce_snapmirror_vol.assert_called_with( 

636 self.source_vserver, self.fake_src_vol_name, 

637 self.dest_vserver, self.fake_dest_vol_name) 

638 

639 self.mock_dest_client.abort_snapmirror_vol.assert_called_once_with( 

640 self.source_vserver, self.fake_src_vol_name, 

641 self.dest_vserver, self.fake_dest_vol_name, 

642 clear_checkpoint=False 

643 ) 

644 

645 def test_quiesce_then_abort_svm_timeout(self): 

646 self.mock_object(time, 'sleep') 

647 mock_get_snapmirrors = mock.Mock( 

648 return_value=[{'relationship-status': "transferring"}]) 

649 self.mock_object(self.mock_dest_client, 'get_snapmirrors_svm', 

650 mock_get_snapmirrors) 

651 mock_backend_config = na_fakes.create_configuration() 

652 mock_backend_config.netapp_snapmirror_quiesce_timeout = 10 

653 self.mock_object(data_motion, 'get_backend_configuration', 

654 mock.Mock(return_value=mock_backend_config)) 

655 

656 self.dm_session.quiesce_then_abort_svm(self.fake_src_share_server, 

657 self.fake_dest_share_server) 

658 

659 self.mock_dest_client.get_snapmirrors_svm.assert_called_with( 

660 source_vserver=self.source_vserver, 

661 dest_vserver=self.dest_vserver, 

662 desired_attributes=['relationship-status', 'mirror-state'] 

663 ) 

664 self.assertEqual(2, 

665 self.mock_dest_client.get_snapmirrors_svm.call_count) 

666 

667 self.mock_dest_client.quiesce_snapmirror_svm.assert_called_with( 

668 self.source_vserver, self.dest_vserver) 

669 

670 self.mock_dest_client.abort_snapmirror_svm.assert_called_once_with( 

671 self.source_vserver, self.dest_vserver, 

672 clear_checkpoint=False 

673 ) 

674 

675 def test_quiesce_then_abort_wait_for_quiesced(self): 

676 self.mock_object(time, 'sleep') 

677 self.mock_object(self.mock_dest_client, 'get_snapmirrors', 

678 mock.Mock(side_effect=[ 

679 [{'relationship-status': "transferring"}], 

680 [{'relationship-status': "quiesced"}]])) 

681 

682 self.dm_session.quiesce_then_abort(self.fake_src_share, 

683 self.fake_dest_share) 

684 

685 self.mock_dest_client.get_snapmirrors.assert_called_with( 

686 source_vserver=self.source_vserver, 

687 dest_vserver=self.dest_vserver, 

688 source_volume=self.fake_src_vol_name, 

689 dest_volume=self.fake_dest_vol_name, 

690 desired_attributes=['relationship-status', 'mirror-state'] 

691 ) 

692 self.assertEqual(2, self.mock_dest_client.get_snapmirrors.call_count) 

693 

694 self.mock_dest_client.quiesce_snapmirror_vol.assert_called_once_with( 

695 self.source_vserver, self.fake_src_vol_name, 

696 self.dest_vserver, self.fake_dest_vol_name) 

697 

698 def test_quiesce_then_abort_svm_wait_for_quiesced(self): 

699 self.mock_object(time, 'sleep') 

700 self.mock_object(self.mock_dest_client, 'get_snapmirrors_svm', 

701 mock.Mock(side_effect=[ 

702 [{'relationship-status': "transferring"}], 

703 [{'relationship-status': "quiesced"}]])) 

704 

705 self.dm_session.quiesce_then_abort_svm(self.fake_src_share_server, 

706 self.fake_dest_share_server) 

707 

708 self.mock_dest_client.get_snapmirrors_svm.assert_called_with( 

709 source_vserver=self.source_vserver, 

710 dest_vserver=self.dest_vserver, 

711 desired_attributes=['relationship-status', 'mirror-state'] 

712 ) 

713 self.assertEqual(2, 

714 self.mock_dest_client.get_snapmirrors_svm.call_count) 

715 

716 self.mock_dest_client.quiesce_snapmirror_svm.assert_called_once_with( 

717 self.source_vserver, self.dest_vserver) 

718 

719 def test_resync_snapmirror(self): 

720 self.dm_session.resync_snapmirror(self.fake_src_share, 

721 self.fake_dest_share) 

722 

723 self.mock_dest_client.resync_snapmirror_vol.assert_called_once_with( 

724 self.source_vserver, self.fake_src_vol_name, 

725 self.dest_vserver, self.fake_dest_vol_name) 

726 

727 def test_change_snapmirror_source(self): 

728 fake_new_src_share = copy.deepcopy(fake.SHARE) 

729 fake_new_src_share['id'] = 'd02d497a-236c-4852-812a-0d39373e312a' 

730 fake_new_src_share_name = 'share_d02d497a_236c_4852_812a_0d39373e312a' 

731 mock_new_src_client = mock.Mock() 

732 self.mock_object(self.dm_session, 'delete_snapmirror') 

733 self.mock_object(data_motion, 'get_client_for_backend', 

734 mock.Mock(side_effect=[self.mock_dest_client, 

735 self.mock_src_client, 

736 self.mock_dest_client, 

737 mock_new_src_client])) 

738 self.mock_object(na_utils, 'get_relationship_type', 

739 mock.Mock(return_value=na_utils.DATA_PROTECTION_TYPE)) 

740 

741 self.dm_session.change_snapmirror_source( 

742 self.fake_dest_share, self.fake_src_share, fake_new_src_share, 

743 [self.fake_dest_share, self.fake_src_share, fake_new_src_share])