Coverage for manila/tests/share/drivers/dell_emc/plugins/powermax/test

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

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

6# a copy of the License at

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

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

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

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

13# License for the specific language governing permissions and limitations

14# under the License.

16import copy

17from unittest import mock

19import ddt

20from oslo_log import log

22from manila import exception

23from manila.share.drivers.dell_emc.common.enas import connector

24from manila.share.drivers.dell_emc.common.enas import utils as enas_utils

25from manila.share.drivers.dell_emc.plugins.vnx import connection

26from manila.share.drivers.dell_emc.plugins.vnx import object_manager

27from manila import test

28from manila.tests import fake_share

29from manila.tests.share.drivers.dell_emc.common.enas import fakes

30from manila.tests.share.drivers.dell_emc.common.enas import utils

32LOG = log.getLogger(__name__)

35@ddt.ddt

36class StorageConnectionTestCase(test.TestCase):

37 @mock.patch.object(connector.XMLAPIConnector, "_do_setup", mock.Mock())

38 def setUp(self):

39 super(StorageConnectionTestCase, self).setUp()

40 self.emc_share_driver = fakes.FakeEMCShareDriver()

42 self.connection = connection.VNXStorageConnection(LOG)

44 self.pool = fakes.PoolTestData()

45 self.vdm = fakes.VDMTestData()

46 self.mover = fakes.MoverTestData()

47 self.fs = fakes.FileSystemTestData()

48 self.mount = fakes.MountPointTestData()

49 self.snap = fakes.SnapshotTestData()

50 self.cifs_share = fakes.CIFSShareTestData()

51 self.nfs_share = fakes.NFSShareTestData()

52 self.cifs_server = fakes.CIFSServerTestData()

53 self.dns = fakes.DNSDomainTestData()

55 with mock.patch.object(connector.XMLAPIConnector, 'request',

56 mock.Mock()):

57 self.connection.connect(self.emc_share_driver, None)

59 def test_check_for_setup_error(self):

60 hook = utils.RequestSideEffect()

61 hook.append(self.mover.resp_get_ref_succeed())

62 xml_req_mock = utils.EMCMock(side_effect=hook)

63 self.connection.manager.connectors['XML'].request = xml_req_mock

65 with mock.patch.object(connection.VNXStorageConnection,

66 '_get_managed_storage_pools',

67 mock.Mock()):

68 self.connection.check_for_setup_error()

70 expected_calls = [mock.call(self.mover.req_get_ref())]

71 xml_req_mock.assert_has_calls(expected_calls)

73 def test_check_for_setup_error_with_invalid_mover_name(self):

74 hook = utils.RequestSideEffect()

75 hook.append(self.mover.resp_get_error())

76 xml_req_mock = utils.EMCMock(side_effect=hook)

77 self.connection.manager.connectors['XML'].request = xml_req_mock

79 self.assertRaises(exception.InvalidParameterValue,

80 self.connection.check_for_setup_error)

82 expected_calls = [mock.call(self.mover.req_get_ref())]

83 xml_req_mock.assert_has_calls(expected_calls)

85 @ddt.data({'pool_conf': None,

86 'real_pools': ['fake_pool', 'nas_pool'],

87 'matched_pool': set()},

88 {'pool_conf': [],

89 'real_pools': ['fake_pool', 'nas_pool'],

90 'matched_pool': set()},

91 {'pool_conf': ['*'],

92 'real_pools': ['fake_pool', 'nas_pool'],

93 'matched_pool': {'fake_pool', 'nas_pool'}},

94 {'pool_conf': ['fake_*'],

95 'real_pools': ['fake_pool', 'nas_pool', 'Perf_Pool'],

96 'matched_pool': {'fake_pool'}},

97 {'pool_conf': ['*pool'],

98 'real_pools': ['fake_pool', 'NAS_Pool', 'Perf_POOL'],

99 'matched_pool': {'fake_pool'}},

100 {'pool_conf': ['nas_pool'],

101 'real_pools': ['fake_pool', 'nas_pool', 'perf_pool'],

102 'matched_pool': {'nas_pool'}})

103 @ddt.unpack

104 def test__get_managed_storage_pools(self, pool_conf, real_pools,

105 matched_pool):

106 with mock.patch.object(object_manager.StoragePool,

107 'get_all',

108 mock.Mock(return_value=('ok', real_pools))):

109 pool = self.connection._get_managed_storage_pools(pool_conf)

110 self.assertEqual(matched_pool, pool)

111

112 def test__get_managed_storage_pools_failed_to_get_pool_info(self):

113 hook = utils.RequestSideEffect()

114 hook.append(self.pool.resp_get_error())

115 xml_req_mock = utils.EMCMock(side_effect=hook)

116 self.connection.manager.connectors['XML'].request = xml_req_mock

117

118 pool_conf = fakes.FakeData.pool_name

119 self.assertRaises(exception.EMCVnxXMLAPIError,

120 self.connection._get_managed_storage_pools,

121 pool_conf)

122

123 expected_calls = [mock.call(self.pool.req_get())]

124 xml_req_mock.assert_has_calls(expected_calls)

125

126 @ddt.data(

127 {'pool_conf': ['fake_*'],

128 'real_pools': ['nas_pool', 'Perf_Pool']},

129 {'pool_conf': ['*pool'],

130 'real_pools': ['NAS_Pool', 'Perf_POOL']},

131 {'pool_conf': ['nas_pool'],

132 'real_pools': ['fake_pool', 'perf_pool']},

133 )

134 @ddt.unpack

135 def test__get_managed_storage_pools_without_matched_pool(self, pool_conf,

136 real_pools):

137 with mock.patch.object(object_manager.StoragePool,

138 'get_all',

139 mock.Mock(return_value=('ok', real_pools))):

140 self.assertRaises(exception.InvalidParameterValue,

141 self.connection._get_managed_storage_pools,

142 pool_conf)

143

144 def test_create_cifs_share(self):

145 share_server = fakes.SHARE_SERVER

146 share = fakes.CIFS_SHARE

147

148 hook = utils.RequestSideEffect()

149 hook.append(self.vdm.resp_get_succeed())

150 hook.append(self.cifs_server.resp_get_succeed(

151 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True))

152 hook.append(self.pool.resp_get_succeed())

153 hook.append(self.fs.resp_task_succeed())

154 hook.append(self.cifs_share.resp_task_succeed())

155 xml_req_mock = utils.EMCMock(side_effect=hook)

156 self.connection.manager.connectors['XML'].request = xml_req_mock

157

158 ssh_hook = utils.SSHSideEffect()

159 ssh_hook.append()

160 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

161 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

162

163 location = self.connection.create_share(None, share, share_server)

164

165 expected_calls = [

166 mock.call(self.vdm.req_get()),

167 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

168 mock.call(self.pool.req_get()),

169 mock.call(self.fs.req_create_on_vdm()),

170 mock.call(self.cifs_share.req_create(self.vdm.vdm_id)),

171 ]

172 xml_req_mock.assert_has_calls(expected_calls)

173

174 ssh_calls = [mock.call(self.cifs_share.cmd_disable_access(), True)]

175 ssh_cmd_mock.assert_has_calls(ssh_calls)

176

177 self.assertEqual(location,

178 [{'path': r'\\%s\%s' % (

179 fakes.FakeData.network_allocations_ip1,

180 share['name'])}],

181 'CIFS export path is incorrect')

182

183 def test_create_cifs_share_with_ipv6(self):

184 share_server = fakes.SHARE_SERVER_IPV6

185 share = fakes.CIFS_SHARE

186

187 hook = utils.RequestSideEffect()

188 hook.append(self.vdm.resp_get_succeed(

189 interface1=fakes.FakeData.interface_name3,

190 interface2=fakes.FakeData.interface_name4))

191 hook.append(self.cifs_server.resp_get_succeed(

192 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True,

193 ip_addr=fakes.FakeData.network_allocations_ip3))

194 hook.append(self.pool.resp_get_succeed())

195 hook.append(self.fs.resp_task_succeed())

196 hook.append(self.cifs_share.resp_task_succeed())

197 xml_req_mock = utils.EMCMock(side_effect=hook)

198 self.connection.manager.connectors['XML'].request = xml_req_mock

199

200 ssh_hook = utils.SSHSideEffect()

201 ssh_hook.append()

202 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

203 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

204

205 location = self.connection.create_share(None, share, share_server)

206

207 expected_calls = [

208 mock.call(self.vdm.req_get()),

209 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

210 mock.call(self.pool.req_get()),

211 mock.call(self.fs.req_create_on_vdm()),

212 mock.call(self.cifs_share.req_create(self.vdm.vdm_id)),

213 ]

214 xml_req_mock.assert_has_calls(expected_calls)

215

216 ssh_calls = [mock.call(self.cifs_share.cmd_disable_access(), True)]

217 ssh_cmd_mock.assert_has_calls(ssh_calls)

218

219 self.assertEqual(

220 location,

221 [{'path': r'\\%s.ipv6-literal.net\%s' % (

222 fakes.FakeData.network_allocations_ip3.replace(':', '-'),

223 share['name'])}],

224 'CIFS export path is incorrect')

225

226 def test_create_nfs_share(self):

227 share_server = fakes.SHARE_SERVER

228 share = fakes.NFS_SHARE

229

230 hook = utils.RequestSideEffect()

231 hook.append(self.pool.resp_get_succeed())

232 hook.append(self.vdm.resp_get_succeed())

233 hook.append(self.fs.resp_task_succeed())

234 xml_req_mock = utils.EMCMock(side_effect=hook)

235 self.connection.manager.connectors['XML'].request = xml_req_mock

236

237 ssh_hook = utils.SSHSideEffect()

238 ssh_hook.append(self.nfs_share.output_create())

239 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

240 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

241

242 location = self.connection.create_share(None, share, share_server)

243

244 expected_calls = [

245 mock.call(self.pool.req_get()),

246 mock.call(self.vdm.req_get()),

247 mock.call(self.fs.req_create_on_vdm()),

248 ]

249 xml_req_mock.assert_has_calls(expected_calls)

250

251 ssh_calls = [mock.call(self.nfs_share.cmd_create(), True)]

252 ssh_cmd_mock.assert_has_calls(ssh_calls)

253

254 self.assertEqual(location,

255 [{'path': '192.168.1.2:/%s' % share['name']}],

256 'NFS export path is incorrect')

257

258 def test_create_nfs_share_with_ipv6(self):

259 share_server = fakes.SHARE_SERVER_IPV6

260 share = fakes.NFS_SHARE

261

262 hook = utils.RequestSideEffect()

263 hook.append(self.pool.resp_get_succeed())

264 hook.append(self.vdm.resp_get_succeed(

265 interface1=fakes.FakeData.interface_name3,

266 interface2=fakes.FakeData.interface_name4))

267 hook.append(self.fs.resp_task_succeed())

268 xml_req_mock = utils.EMCMock(side_effect=hook)

269 self.connection.manager.connectors['XML'].request = xml_req_mock

270

271 ssh_hook = utils.SSHSideEffect()

272 ssh_hook.append(self.nfs_share.output_create())

273 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

274 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

275

276 location = self.connection.create_share(None, share, share_server)

277

278 expected_calls = [

279 mock.call(self.pool.req_get()),

280 mock.call(self.vdm.req_get()),

281 mock.call(self.fs.req_create_on_vdm()),

282 ]

283 xml_req_mock.assert_has_calls(expected_calls)

284

285 ssh_calls = [mock.call(self.nfs_share.cmd_create(), True)]

286 ssh_cmd_mock.assert_has_calls(ssh_calls)

287

288 self.assertEqual(location,

289 [{'path': '[%s]:/%s' % (

290 fakes.FakeData.network_allocations_ip4,

291 share['name'])}],

292 'NFS export path is incorrect')

293

294 def test_create_cifs_share_without_share_server(self):

295 share = fakes.CIFS_SHARE

296

297 self.assertRaises(exception.InvalidInput,

298 self.connection.create_share,

299 None, share, None)

300

301 def test_create_cifs_share_without_share_server_name(self):

302 share = fakes.CIFS_SHARE

303 share_server = copy.deepcopy(fakes.SHARE_SERVER)

304 share_server['backend_details']['share_server_name'] = None

305

306 self.assertRaises(exception.EMCVnxXMLAPIError,

307 self.connection.create_share,

308 None, share, share_server)

309

310 def test_create_cifs_share_with_invalide_cifs_server_name(self):

311 share_server = fakes.SHARE_SERVER

312 share = fakes.CIFS_SHARE

313

314 hook = utils.RequestSideEffect()

315 hook.append(self.vdm.resp_get_succeed())

316 hook.append(self.cifs_server.resp_get_error())

317 xml_req_mock = utils.EMCMock(side_effect=hook)

318 self.connection.manager.connectors['XML'].request = xml_req_mock

319

320 self.assertRaises(exception.EMCVnxXMLAPIError,

321 self.connection.create_share,

322 None, share, share_server)

323

324 expected_calls = [

325 mock.call(self.vdm.req_get()),

326 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

327 ]

328 xml_req_mock.assert_has_calls(expected_calls)

329

330 def test_create_cifs_share_without_interface_in_cifs_server(self):

331 share_server = fakes.SHARE_SERVER

332 share = fakes.CIFS_SHARE

333

334 hook = utils.RequestSideEffect()

335 hook.append(self.vdm.resp_get_succeed())

336 hook.append(self.cifs_server.resp_get_without_interface(

337 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True))

338 hook.append(self.pool.resp_get_succeed())

339 hook.append(self.fs.resp_task_succeed())

340 xml_req_mock = utils.EMCMock(side_effect=hook)

341 self.connection.manager.connectors['XML'].request = xml_req_mock

342

343 self.assertRaises(exception.EMCVnxXMLAPIError,

344 self.connection.create_share,

345 None, share, share_server)

346

347 expected_calls = [

348 mock.call(self.vdm.req_get()),

349 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

350 mock.call(self.pool.req_get()),

351 mock.call(self.fs.req_create_on_vdm()),

352

353 ]

354 xml_req_mock.assert_has_calls(expected_calls)

355

356 def test_create_cifs_share_without_pool_name(self):

357 share_server = fakes.SHARE_SERVER

358 share = fake_share.fake_share(host='HostA@BackendB',

359 share_proto='CIFS')

360

361 self.assertRaises(exception.InvalidHost,

362 self.connection.create_share,

363 None, share, share_server)

364

365 def test_create_cifs_share_from_snapshot(self):

366 share_server = fakes.SHARE_SERVER

367 share = fakes.CIFS_SHARE

368 snapshot = fake_share.fake_snapshot(

369 name=fakes.FakeData.src_snap_name,

370 share_name=fakes.FakeData.src_share_name,

371 share_id=fakes.FakeData.src_share_name,

372 id=fakes.FakeData.src_snap_name)

373

374 hook = utils.RequestSideEffect()

375 hook.append(self.fs.resp_get_succeed())

376 hook.append(self.vdm.resp_get_succeed())

377 hook.append(self.cifs_server.resp_get_succeed(

378 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True))

379 hook.append(self.cifs_share.resp_task_succeed())

380 xml_req_mock = utils.EMCMock(side_effect=hook)

381 self.connection.manager.connectors['XML'].request = xml_req_mock

382

383 ssh_hook = utils.SSHSideEffect()

384 ssh_hook.append(self.mover.output_get_interconnect_id())

385 ssh_hook.append()

386 ssh_hook.append()

387 ssh_hook.append(self.fs.output_copy_ckpt)

388 ssh_hook.append(self.fs.output_info())

389 ssh_hook.append()

390 ssh_hook.append()

391 ssh_hook.append()

392 ssh_hook.append()

393 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

394 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

395

396 location = self.connection.create_share_from_snapshot(

397 None, share, snapshot, share_server)

398

399 expected_calls = [

400 mock.call(self.fs.req_get()),

401 mock.call(self.vdm.req_get()),

402 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

403 mock.call(self.cifs_share.req_create(self.vdm.vdm_id)),

404 ]

405 xml_req_mock.assert_has_calls(expected_calls)

406

407 ssh_calls = [

408 mock.call(self.mover.cmd_get_interconnect_id(), False),

409 mock.call(self.fs.cmd_create_from_ckpt(), False),

410 mock.call(self.mount.cmd_server_mount('ro'), False),

411 mock.call(self.fs.cmd_copy_ckpt(), True),

412 mock.call(self.fs.cmd_nas_fs_info(), False),

413 mock.call(self.mount.cmd_server_umount(), False),

414 mock.call(self.fs.cmd_delete(), False),

415 mock.call(self.mount.cmd_server_mount('rw'), False),

416 mock.call(self.cifs_share.cmd_disable_access(), True),

417 ]

418 ssh_cmd_mock.assert_has_calls(ssh_calls)

419

420 self.assertEqual(location,

421 [{'path': r'\\192.168.1.1\%s' % share['name']}],

422 'CIFS export path is incorrect')

423

424 def test_create_cifs_share_from_snapshot_with_ipv6(self):

425 share_server = fakes.SHARE_SERVER_IPV6

426 share = fakes.CIFS_SHARE

427 snapshot = fake_share.fake_snapshot(

428 name=fakes.FakeData.src_snap_name,

429 share_name=fakes.FakeData.src_share_name,

430 share_id=fakes.FakeData.src_share_name,

431 id=fakes.FakeData.src_snap_name)

432

433 hook = utils.RequestSideEffect()

434 hook.append(self.fs.resp_get_succeed())

435 hook.append(self.vdm.resp_get_succeed(

436 interface1=fakes.FakeData.interface_name3,

437 interface2=fakes.FakeData.interface_name4))

438 hook.append(self.cifs_server.resp_get_succeed(

439 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True,

440 ip_addr=fakes.FakeData.network_allocations_ip3))

441 hook.append(self.cifs_share.resp_task_succeed())

442 xml_req_mock = utils.EMCMock(side_effect=hook)

443 self.connection.manager.connectors['XML'].request = xml_req_mock

444

445 ssh_hook = utils.SSHSideEffect()

446 ssh_hook.append(self.mover.output_get_interconnect_id())

447 ssh_hook.append()

448 ssh_hook.append()

449 ssh_hook.append(self.fs.output_copy_ckpt)

450 ssh_hook.append(self.fs.output_info())

451 ssh_hook.append()

452 ssh_hook.append()

453 ssh_hook.append()

454 ssh_hook.append()

455 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

456 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

457

458 location = self.connection.create_share_from_snapshot(

459 None, share, snapshot, share_server)

460

461 expected_calls = [

462 mock.call(self.fs.req_get()),

463 mock.call(self.vdm.req_get()),

464 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

465 mock.call(self.cifs_share.req_create(self.vdm.vdm_id)),

466 ]

467 xml_req_mock.assert_has_calls(expected_calls)

468

469 ssh_calls = [

470 mock.call(self.mover.cmd_get_interconnect_id(), False),

471 mock.call(self.fs.cmd_create_from_ckpt(), False),

472 mock.call(self.mount.cmd_server_mount('ro'), False),

473 mock.call(self.fs.cmd_copy_ckpt(), True),

474 mock.call(self.fs.cmd_nas_fs_info(), False),

475 mock.call(self.mount.cmd_server_umount(), False),

476 mock.call(self.fs.cmd_delete(), False),

477 mock.call(self.mount.cmd_server_mount('rw'), False),

478 mock.call(self.cifs_share.cmd_disable_access(), True),

479 ]

480 ssh_cmd_mock.assert_has_calls(ssh_calls)

481

482 self.assertEqual(

483 location,

484 [{'path': r'\\%s.ipv6-literal.net\%s' % (

485 fakes.FakeData.network_allocations_ip3.replace(':', '-'),

486 share['name'])}],

487 'CIFS export path is incorrect')

488

489 def test_create_nfs_share_from_snapshot(self):

490 share_server = fakes.SHARE_SERVER

491 share = fakes.NFS_SHARE

492 snapshot = fake_share.fake_snapshot(

493 name=fakes.FakeData.src_snap_name,

494 share_name=fakes.FakeData.src_share_name,

495 share_id=fakes.FakeData.src_share_name,

496 id=fakes.FakeData.src_snap_name)

497

498 hook = utils.RequestSideEffect()

499 hook.append(self.fs.resp_get_succeed())

500 xml_req_mock = utils.EMCMock(side_effect=hook)

501 self.connection.manager.connectors['XML'].request = xml_req_mock

502

503 ssh_hook = utils.SSHSideEffect()

504 ssh_hook.append(self.mover.output_get_interconnect_id())

505 ssh_hook.append()

506 ssh_hook.append()

507 ssh_hook.append(self.fs.output_copy_ckpt)

508 ssh_hook.append(self.fs.output_info())

509 ssh_hook.append()

510 ssh_hook.append()

511 ssh_hook.append()

512 ssh_hook.append(self.nfs_share.output_create())

513 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

514 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

515

516 location = self.connection.create_share_from_snapshot(

517 None, share, snapshot, share_server)

518

519 expected_calls = [mock.call(self.fs.req_get())]

520 xml_req_mock.assert_has_calls(expected_calls)

521

522 ssh_calls = [

523 mock.call(self.mover.cmd_get_interconnect_id(), False),

524 mock.call(self.fs.cmd_create_from_ckpt(), False),

525 mock.call(self.mount.cmd_server_mount('ro'), False),

526 mock.call(self.fs.cmd_copy_ckpt(), True),

527 mock.call(self.fs.cmd_nas_fs_info(), False),

528 mock.call(self.mount.cmd_server_umount(), False),

529 mock.call(self.fs.cmd_delete(), False),

530 mock.call(self.mount.cmd_server_mount('rw'), False),

531 mock.call(self.nfs_share.cmd_create(), True)

532 ]

533 ssh_cmd_mock.assert_has_calls(ssh_calls)

534

535 self.assertEqual(location,

536 [{'path': '192.168.1.2:/%s' % share['name']}],

537 'NFS export path is incorrect')

538

539 def test_create_nfs_share_from_snapshot_with_ipv6(self):

540 share_server = fakes.SHARE_SERVER_IPV6

541 share = fakes.NFS_SHARE

542 snapshot = fake_share.fake_snapshot(

543 name=fakes.FakeData.src_snap_name,

544 share_name=fakes.FakeData.src_share_name,

545 share_id=fakes.FakeData.src_share_name,

546 id=fakes.FakeData.src_snap_name)

547

548 hook = utils.RequestSideEffect()

549 hook.append(self.fs.resp_get_succeed())

550 xml_req_mock = utils.EMCMock(side_effect=hook)

551 self.connection.manager.connectors['XML'].request = xml_req_mock

552

553 ssh_hook = utils.SSHSideEffect()

554 ssh_hook.append(self.mover.output_get_interconnect_id())

555 ssh_hook.append()

556 ssh_hook.append()

557 ssh_hook.append(self.fs.output_copy_ckpt)

558 ssh_hook.append(self.fs.output_info())

559 ssh_hook.append()

560 ssh_hook.append()

561 ssh_hook.append()

562 ssh_hook.append(self.nfs_share.output_create())

563 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

564 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

565

566 location = self.connection.create_share_from_snapshot(

567 None, share, snapshot, share_server)

568

569 expected_calls = [mock.call(self.fs.req_get())]

570 xml_req_mock.assert_has_calls(expected_calls)

571

572 ssh_calls = [

573 mock.call(self.mover.cmd_get_interconnect_id(), False),

574 mock.call(self.fs.cmd_create_from_ckpt(), False),

575 mock.call(self.mount.cmd_server_mount('ro'), False),

576 mock.call(self.fs.cmd_copy_ckpt(), True),

577 mock.call(self.fs.cmd_nas_fs_info(), False),

578 mock.call(self.mount.cmd_server_umount(), False),

579 mock.call(self.fs.cmd_delete(), False),

580 mock.call(self.mount.cmd_server_mount('rw'), False),

581 mock.call(self.nfs_share.cmd_create(), True)

582 ]

583 ssh_cmd_mock.assert_has_calls(ssh_calls)

584

585 self.assertEqual(

586 location,

587 [{'path': '[%s]:/%s' % (

588 fakes.FakeData.network_allocations_ip4,

589 share['name'])}],

590 'NFS export path is incorrect')

591

592 def test_create_share_with_incorrect_proto(self):

593 share_server = fakes.SHARE_SERVER

594 share = fake_share.fake_share(share_proto='FAKE_PROTO')

595

596 self.assertRaises(exception.InvalidShare,

597 self.connection.create_share,

598 context=None,

599 share=share,

600 share_server=share_server)

601

602 def test_create_share_from_snapshot_with_incorrect_proto(self):

603 share_server = fakes.SHARE_SERVER

604 share = fake_share.fake_share(share_proto='FAKE_PROTO')

605 snapshot = fake_share.fake_snapshot()

606

607 self.assertRaises(exception.InvalidShare,

608 self.connection.create_share_from_snapshot,

609 None, share, snapshot, share_server)

610

611 def test_create_share_from_snapshot_without_pool_name(self):

612 share_server = fakes.SHARE_SERVER

613 share = fake_share.fake_share(host='HostA@BackendB',

614 share_proto='CIFS')

615 snapshot = fake_share.fake_snapshot()

616

617 self.assertRaises(exception.InvalidHost,

618 self.connection.create_share_from_snapshot,

619 None, share, snapshot, share_server)

620

621 def test_delete_cifs_share(self):

622 share_server = fakes.SHARE_SERVER

623 share = fakes.CIFS_SHARE

624

625 hook = utils.RequestSideEffect()

626 hook.append(self.cifs_share.resp_get_succeed(self.vdm.vdm_id))

627 hook.append(self.vdm.resp_get_succeed())

628 hook.append(self.cifs_share.resp_task_succeed())

629 hook.append(self.mount.resp_task_succeed())

630 hook.append(self.fs.resp_get_succeed())

631 hook.append(self.fs.resp_task_succeed())

632 xml_req_mock = utils.EMCMock(side_effect=hook)

633 self.connection.manager.connectors['XML'].request = xml_req_mock

634

635 self.connection.delete_share(None, share, share_server)

636

637 expected_calls = [

638 mock.call(self.cifs_share.req_get()),

639 mock.call(self.vdm.req_get()),

640 mock.call(self.cifs_share.req_delete(self.vdm.vdm_id)),

641 mock.call(self.mount.req_delete(self.vdm.vdm_id)),

642 mock.call(self.fs.req_get()),

643 mock.call(self.fs.req_delete()),

644 ]

645 xml_req_mock.assert_has_calls(expected_calls)

646

647 def test_delete_cifs_share_with_ipv6(self):

648 share_server = fakes.SHARE_SERVER_IPV6

649 share = fakes.CIFS_SHARE

650

651 hook = utils.RequestSideEffect()

652 hook.append(self.cifs_share.resp_get_succeed(self.vdm.vdm_id))

653 hook.append(self.vdm.resp_get_succeed(

654 interface1=fakes.FakeData.interface_name3,

655 interface2=fakes.FakeData.interface_name4))

656 hook.append(self.cifs_share.resp_task_succeed())

657 hook.append(self.mount.resp_task_succeed())

658 hook.append(self.fs.resp_get_succeed())

659 hook.append(self.fs.resp_task_succeed())

660 xml_req_mock = utils.EMCMock(side_effect=hook)

661 self.connection.manager.connectors['XML'].request = xml_req_mock

662

663 self.connection.delete_share(None, share, share_server)

664

665 expected_calls = [

666 mock.call(self.cifs_share.req_get()),

667 mock.call(self.vdm.req_get()),

668 mock.call(self.cifs_share.req_delete(self.vdm.vdm_id)),

669 mock.call(self.mount.req_delete(self.vdm.vdm_id)),

670 mock.call(self.fs.req_get()),

671 mock.call(self.fs.req_delete()),

672 ]

673 xml_req_mock.assert_has_calls(expected_calls)

674

675 def test_delete_nfs_share(self):

676 share_server = fakes.SHARE_SERVER

677 share = fakes.NFS_SHARE

678

679 hook = utils.RequestSideEffect()

680 hook.append(self.vdm.resp_get_succeed())

681 hook.append(self.mount.resp_task_succeed())

682 hook.append(self.fs.resp_get_succeed())

683 hook.append(self.fs.resp_task_succeed())

684 xml_req_mock = utils.EMCMock(side_effect=hook)

685 self.connection.manager.connectors['XML'].request = xml_req_mock

686

687 ssh_hook = utils.SSHSideEffect()

688 ssh_hook.append(self.nfs_share.output_get_succeed(

689 rw_hosts=self.nfs_share.rw_hosts,

690 ro_hosts=self.nfs_share.ro_hosts))

691 ssh_hook.append(self.nfs_share.output_delete_succeed())

692 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

693 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

694

695 self.connection.delete_share(None, share, share_server)

696

697 expected_calls = [

698 mock.call(self.vdm.req_get()),

699 mock.call(self.mount.req_delete(self.vdm.vdm_id)),

700 mock.call(self.fs.req_get()),

701 mock.call(self.fs.req_delete()),

702 ]

703 xml_req_mock.assert_has_calls(expected_calls)

704

705 ssh_calls = [

706 mock.call(self.nfs_share.cmd_get(), False),

707 mock.call(self.nfs_share.cmd_delete(), True),

708 ]

709 ssh_cmd_mock.assert_has_calls(ssh_calls)

710

711 def test_delete_nfs_share_with_ipv6(self):

712 share_server = fakes.SHARE_SERVER_IPV6

713 share = fakes.NFS_SHARE

714

715 hook = utils.RequestSideEffect()

716 hook.append(self.vdm.resp_get_succeed(

717 interface1=fakes.FakeData.interface_name3,

718 interface2=fakes.FakeData.interface_name4))

719 hook.append(self.mount.resp_task_succeed())

720 hook.append(self.fs.resp_get_succeed())

721 hook.append(self.fs.resp_task_succeed())

722 xml_req_mock = utils.EMCMock(side_effect=hook)

723 self.connection.manager.connectors['XML'].request = xml_req_mock

724

725 ssh_hook = utils.SSHSideEffect()

726 ssh_hook.append(self.nfs_share.output_get_succeed(

727 rw_hosts=self.nfs_share.rw_hosts,

728 ro_hosts=self.nfs_share.ro_hosts))

729 ssh_hook.append(self.nfs_share.output_delete_succeed())

730 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

731 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

732

733 self.connection.delete_share(None, share, share_server)

734

735 expected_calls = [

736 mock.call(self.vdm.req_get()),

737 mock.call(self.mount.req_delete(self.vdm.vdm_id)),

738 mock.call(self.fs.req_get()),

739 mock.call(self.fs.req_delete()),

740 ]

741 xml_req_mock.assert_has_calls(expected_calls)

742

743 ssh_calls = [

744 mock.call(self.nfs_share.cmd_get(), False),

745 mock.call(self.nfs_share.cmd_delete(), True),

746 ]

747 ssh_cmd_mock.assert_has_calls(ssh_calls)

748

749 def test_delete_share_without_share_server(self):

750 share = fakes.CIFS_SHARE

751

752 self.connection.delete_share(None, share)

753

754 def test_delete_share_with_incorrect_proto(self):

755 share_server = fakes.SHARE_SERVER

756 share = fake_share.fake_share(share_proto='FAKE_PROTO')

757

758 self.assertRaises(exception.InvalidShare,

759 self.connection.delete_share,

760 context=None,

761 share=share,

762 share_server=share_server)

763

764 def test_delete_cifs_share_with_nonexistent_mount_and_filesystem(self):

765 share_server = fakes.SHARE_SERVER

766 share = fakes.CIFS_SHARE

767

768 hook = utils.RequestSideEffect()

769 hook.append(self.cifs_share.resp_get_succeed(self.vdm.vdm_id))

770 hook.append(self.vdm.resp_get_succeed())

771 hook.append(self.cifs_share.resp_task_succeed())

772 hook.append(self.mount.resp_task_error())

773 hook.append(self.fs.resp_get_succeed())

774 hook.append(self.fs.resp_task_error())

775 xml_req_mock = utils.EMCMock(side_effect=hook)

776 self.connection.manager.connectors['XML'].request = xml_req_mock

777

778 self.connection.delete_share(None, share, share_server)

779

780 expected_calls = [

781 mock.call(self.cifs_share.req_get()),

782 mock.call(self.vdm.req_get()),

783 mock.call(self.cifs_share.req_delete(self.vdm.vdm_id)),

784 mock.call(self.mount.req_delete(self.vdm.vdm_id)),

785 mock.call(self.fs.req_get()),

786 mock.call(self.fs.req_delete()),

787 ]

788 xml_req_mock.assert_has_calls(expected_calls)

789

790 def test_extend_share(self):

791 share_server = fakes.SHARE_SERVER

792 share = fakes.CIFS_SHARE

793 new_size = fakes.FakeData.new_size

794

795 hook = utils.RequestSideEffect()

796 hook.append(self.fs.resp_get_succeed())

797 hook.append(self.pool.resp_get_succeed())

798 hook.append(self.fs.resp_task_succeed())

799 xml_req_mock = utils.EMCMock(side_effect=hook)

800 self.connection.manager.connectors['XML'].request = xml_req_mock

801

802 self.connection.extend_share(share, new_size, share_server)

803

804 expected_calls = [

805 mock.call(self.fs.req_get()),

806 mock.call(self.pool.req_get()),

807 mock.call(self.fs.req_extend()),

808 ]

809 xml_req_mock.assert_has_calls(expected_calls)

810

811 def test_extend_share_with_ipv6(self):

812 share_server = fakes.SHARE_SERVER_IPV6

813 share = fakes.CIFS_SHARE

814 new_size = fakes.FakeData.new_size

815

816 hook = utils.RequestSideEffect()

817 hook.append(self.fs.resp_get_succeed())

818 hook.append(self.pool.resp_get_succeed())

819 hook.append(self.fs.resp_task_succeed())

820 xml_req_mock = utils.EMCMock(side_effect=hook)

821 self.connection.manager.connectors['XML'].request = xml_req_mock

822

823 self.connection.extend_share(share, new_size, share_server)

824

825 expected_calls = [

826 mock.call(self.fs.req_get()),

827 mock.call(self.pool.req_get()),

828 mock.call(self.fs.req_extend()),

829 ]

830 xml_req_mock.assert_has_calls(expected_calls)

831

832 def test_extend_share_without_pool_name(self):

833 share_server = fakes.SHARE_SERVER

834 share = fake_share.fake_share(host='HostA@BackendB',

835 share_proto='CIFS')

836 new_size = fakes.FakeData.new_size

837

838 self.assertRaises(exception.InvalidHost,

839 self.connection.extend_share,

840 share, new_size, share_server)

841

842 def test_create_snapshot(self):

843 share_server = fakes.SHARE_SERVER

844 snapshot = fake_share.fake_snapshot(

845 id=fakes.FakeData.snapshot_name,

846 share_id=fakes.FakeData.filesystem_name,

847 share_name=fakes.FakeData.share_name)

848

849 hook = utils.RequestSideEffect()

850 hook.append(self.fs.resp_get_succeed())

851 hook.append(self.snap.resp_task_succeed())

852 xml_req_mock = utils.EMCMock(side_effect=hook)

853 self.connection.manager.connectors['XML'].request = xml_req_mock

854

855 self.connection.create_snapshot(None, snapshot, share_server)

856

857 expected_calls = [

858 mock.call(self.fs.req_get()),

859 mock.call(self.snap.req_create()),

860 ]

861 xml_req_mock.assert_has_calls(expected_calls)

862

863 def test_create_snapshot_with_ipv6(self):

864 share_server = fakes.SHARE_SERVER_IPV6

865 snapshot = fake_share.fake_snapshot(

866 id=fakes.FakeData.snapshot_name,

867 share_id=fakes.FakeData.filesystem_name,

868 share_name=fakes.FakeData.share_name)

869

870 hook = utils.RequestSideEffect()

871 hook.append(self.fs.resp_get_succeed())

872 hook.append(self.snap.resp_task_succeed())

873 xml_req_mock = utils.EMCMock(side_effect=hook)

874 self.connection.manager.connectors['XML'].request = xml_req_mock

875

876 self.connection.create_snapshot(None, snapshot, share_server)

877

878 expected_calls = [

879 mock.call(self.fs.req_get()),

880 mock.call(self.snap.req_create()),

881 ]

882 xml_req_mock.assert_has_calls(expected_calls)

883

884 def test_create_snapshot_with_incorrect_share_info(self):

885 share_server = fakes.SHARE_SERVER

886 snapshot = fake_share.fake_snapshot(

887 id=fakes.FakeData.snapshot_name,

888 share_id=fakes.FakeData.filesystem_name,

889 share_name=fakes.FakeData.share_name)

890

891 hook = utils.RequestSideEffect()

892 hook.append(self.fs.resp_get_but_not_found())

893 xml_req_mock = utils.EMCMock(side_effect=hook)

894 self.connection.manager.connectors['XML'].request = xml_req_mock

895

896 self.assertRaises(exception.EMCVnxXMLAPIError,

897 self.connection.create_snapshot,

898 None, snapshot, share_server)

899

900 expected_calls = [mock.call(self.fs.req_get())]

901 xml_req_mock.assert_has_calls(expected_calls)

902

903 def test_delete_snapshot(self):

904 share_server = fakes.SHARE_SERVER

905 snapshot = fake_share.fake_snapshot(

906 id=fakes.FakeData.snapshot_name,

907 share_id=fakes.FakeData.filesystem_name,

908 share_name=fakes.FakeData.share_name)

909

910 hook = utils.RequestSideEffect()

911 hook.append(self.snap.resp_get_succeed())

912 hook.append(self.snap.resp_task_succeed())

913 xml_req_mock = utils.EMCMock(side_effect=hook)

914 self.connection.manager.connectors['XML'].request = xml_req_mock

915

916 self.connection.delete_snapshot(None, snapshot, share_server)

917

918 expected_calls = [

919 mock.call(self.snap.req_get()),

920 mock.call(self.snap.req_delete()),

921 ]

922 xml_req_mock.assert_has_calls(expected_calls)

923

924 def test_delete_snapshot_with_ipv6(self):

925 share_server = fakes.SHARE_SERVER_IPV6

926 snapshot = fake_share.fake_snapshot(

927 id=fakes.FakeData.snapshot_name,

928 share_id=fakes.FakeData.filesystem_name,

929 share_name=fakes.FakeData.share_name)

930

931 hook = utils.RequestSideEffect()

932 hook.append(self.snap.resp_get_succeed())

933 hook.append(self.snap.resp_task_succeed())

934 xml_req_mock = utils.EMCMock(side_effect=hook)

935 self.connection.manager.connectors['XML'].request = xml_req_mock

936

937 self.connection.delete_snapshot(None, snapshot, share_server)

938

939 expected_calls = [

940 mock.call(self.snap.req_get()),

941 mock.call(self.snap.req_delete()),

942 ]

943 xml_req_mock.assert_has_calls(expected_calls)

944

945 @utils.patch_get_managed_ports_vnx(return_value=['cge-1-0'])

946 def test_setup_server(self):

947 hook = utils.RequestSideEffect()

948 hook.append(self.vdm.resp_get_but_not_found())

949 hook.append(self.mover.resp_get_ref_succeed())

950 hook.append(self.vdm.resp_task_succeed())

951 hook.append(self.mover.resp_task_succeed())

952 hook.append(self.mover.resp_task_succeed())

953 hook.append(self.dns.resp_task_succeed())

954 hook.append(self.vdm.resp_get_succeed())

955 hook.append(self.cifs_server.resp_task_succeed())

956 xml_req_mock = utils.EMCMock(side_effect=hook)

957 self.connection.manager.connectors['XML'].request = xml_req_mock

958

959 ssh_hook = utils.SSHSideEffect()

960 ssh_hook.append()

961 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

962 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

963

964 self.connection.setup_server(fakes.NETWORK_INFO, None)

965

966 if_name_1 = fakes.FakeData.interface_name1

967 if_name_2 = fakes.FakeData.interface_name2

968

969 expected_calls = [

970 mock.call(self.vdm.req_get()),

971 mock.call(self.mover.req_get_ref()),

972 mock.call(self.vdm.req_create()),

973 mock.call(self.mover.req_create_interface(

974 if_name=if_name_1,

975 ip=fakes.FakeData.network_allocations_ip1)),

976 mock.call(self.mover.req_create_interface(

977 if_name=if_name_2,

978 ip=fakes.FakeData.network_allocations_ip2)),

979 mock.call(self.dns.req_create()),

980 mock.call(self.vdm.req_get()),

981 mock.call(self.cifs_server.req_create(self.vdm.vdm_id)),

982 ]

983 xml_req_mock.assert_has_calls(expected_calls)

984

985 ssh_calls = [

986 mock.call(self.vdm.cmd_attach_nfs_interface(), False),

987 ]

988 ssh_cmd_mock.assert_has_calls(ssh_calls)

989

990 @utils.patch_get_managed_ports_vnx(return_value=['cge-1-0'])

991 def test_setup_server_with_ipv6(self):

992 hook = utils.RequestSideEffect()

993 hook.append(self.vdm.resp_get_but_not_found())

994 hook.append(self.mover.resp_get_ref_succeed())

995 hook.append(self.vdm.resp_task_succeed())

996 hook.append(self.mover.resp_task_succeed())

997 hook.append(self.mover.resp_task_succeed())

998 hook.append(self.dns.resp_task_succeed())

999 hook.append(self.vdm.resp_get_succeed())

1000 hook.append(self.cifs_server.resp_task_succeed())

1001 xml_req_mock = utils.EMCMock(side_effect=hook)

1002 self.connection.manager.connectors['XML'].request = xml_req_mock

1003

1004 ssh_hook = utils.SSHSideEffect()

1005 ssh_hook.append()

1006 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

1007 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1008

1009 self.connection.setup_server(fakes.NETWORK_INFO_IPV6, None)

1010

1011 if_name_1 = fakes.FakeData.interface_name3

1012 if_name_2 = fakes.FakeData.interface_name4

1013

1014 expect_ip_1 = fakes.FakeData.network_allocations_ip3

1015 expect_ip_2 = fakes.FakeData.network_allocations_ip4

1016

1017 expected_calls = [

1018 mock.call(self.vdm.req_get()),

1019 mock.call(self.mover.req_get_ref()),

1020 mock.call(self.vdm.req_create()),

1021 mock.call(self.mover.req_create_interface_with_ipv6(

1022 if_name=if_name_1,

1023 ip=expect_ip_1)),

1024 mock.call(self.mover.req_create_interface_with_ipv6(

1025 if_name=if_name_2,

1026 ip=expect_ip_2)),

1027 mock.call(self.dns.req_create(

1028 ip_addr=fakes.FakeData.dns_ipv6_address)),

1029 mock.call(self.vdm.req_get()),

1030 mock.call(self.cifs_server.req_create(

1031 self.vdm.vdm_id,

1032 ip_addr=fakes.FakeData.network_allocations_ip3)),

1033 ]

1034 xml_req_mock.assert_has_calls(expected_calls)

1035

1036 ssh_calls = [

1037 mock.call(self.vdm.cmd_attach_nfs_interface(

1038 interface=fakes.FakeData.interface_name4), False),

1039 ]

1040

1041 ssh_cmd_mock.assert_has_calls(ssh_calls)

1042

1043 @utils.patch_get_managed_ports_vnx(return_value=['cge-1-0'])

1044 def test_setup_server_with_existing_vdm(self):

1045 hook = utils.RequestSideEffect()

1046 hook.append(self.vdm.resp_get_succeed())

1047 hook.append(self.mover.resp_get_ref_succeed())

1048 hook.append(self.mover.resp_task_succeed())

1049 hook.append(self.mover.resp_task_succeed())

1050 hook.append(self.dns.resp_task_succeed())

1051 hook.append(self.cifs_server.resp_task_succeed())

1052 xml_req_mock = utils.EMCMock(side_effect=hook)

1053 self.connection.manager.connectors['XML'].request = xml_req_mock

1054

1055 ssh_hook = utils.SSHSideEffect()

1056 ssh_hook.append()

1057 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

1058 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1059 self.connection.setup_server(fakes.NETWORK_INFO, None)

1060

1061 if_name_1 = fakes.FakeData.network_allocations_id1[-12:]

1062 if_name_2 = fakes.FakeData.network_allocations_id2[-12:]

1063

1064 expected_calls = [

1065 mock.call(self.vdm.req_get()),

1066 mock.call(self.mover.req_get_ref()),

1067 mock.call(self.mover.req_create_interface(

1068 if_name=if_name_1,

1069 ip=fakes.FakeData.network_allocations_ip1)),

1070 mock.call(self.mover.req_create_interface(

1071 if_name=if_name_2,

1072 ip=fakes.FakeData.network_allocations_ip2)),

1073 mock.call(self.dns.req_create()),

1074 mock.call(self.cifs_server.req_create(self.vdm.vdm_id)),

1075 ]

1076 xml_req_mock.assert_has_calls(expected_calls)

1077

1078 ssh_calls = [

1079 mock.call(self.vdm.cmd_attach_nfs_interface(), False),

1080 ]

1081 ssh_cmd_mock.assert_has_calls(ssh_calls)

1082

1083 def test_setup_server_with_invalid_security_service(self):

1084 network_info = copy.deepcopy(fakes.NETWORK_INFO)

1085 network_info['security_services'][0]['type'] = 'fake_type'

1086

1087 self.assertRaises(exception.EMCVnxXMLAPIError,

1088 self.connection.setup_server,

1089 network_info, None)

1090

1091 @utils.patch_get_managed_ports_vnx(

1092 side_effect=exception.EMCVnxXMLAPIError(

1093 err="Get managed ports fail."))

1094 def test_setup_server_without_valid_physical_device(self):

1095 hook = utils.RequestSideEffect()

1096 hook.append(self.vdm.resp_get_but_not_found())

1097 hook.append(self.mover.resp_get_ref_succeed())

1098 hook.append(self.vdm.resp_task_succeed())

1099 hook.append(self.vdm.resp_get_succeed())

1100 hook.append(self.cifs_server.resp_get_without_value())

1101 hook.append(self.vdm.resp_task_succeed())

1102 xml_req_mock = utils.EMCMock(side_effect=hook)

1103 self.connection.manager.connectors['XML'].request = xml_req_mock

1104 ssh_hook = utils.SSHSideEffect()

1105 ssh_hook.append(self.vdm.output_get_interfaces_vdm(nfs_interface=''))

1106 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

1107 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1108

1109 self.assertRaises(exception.EMCVnxXMLAPIError,

1110 self.connection.setup_server,

1111 fakes.NETWORK_INFO, None)

1112

1113 expected_calls = [

1114 mock.call(self.vdm.req_get()),

1115 mock.call(self.mover.req_get_ref()),

1116 mock.call(self.vdm.req_create()),

1117 mock.call(self.vdm.req_get()),

1118 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

1119 mock.call(self.vdm.req_delete()),

1120 ]

1121 xml_req_mock.assert_has_calls(expected_calls)

1122

1123 ssh_calls = [

1124 mock.call(self.vdm.cmd_get_interfaces(), False),

1125 ]

1126 ssh_cmd_mock.assert_has_calls(ssh_calls)

1127

1128 @utils.patch_get_managed_ports_vnx(return_value=['cge-1-0'])

1129 def test_setup_server_with_exception(self):

1130 hook = utils.RequestSideEffect()

1131 hook.append(self.vdm.resp_get_but_not_found())

1132 hook.append(self.mover.resp_get_ref_succeed())

1133 hook.append(self.vdm.resp_task_succeed())

1134 hook.append(self.mover.resp_task_succeed())

1135 hook.append(self.mover.resp_task_error())

1136 hook.append(self.vdm.resp_get_succeed())

1137 hook.append(self.cifs_server.resp_get_without_value())

1138 hook.append(self.mover.resp_task_succeed())

1139 hook.append(self.vdm.resp_task_succeed())

1140 xml_req_mock = utils.EMCMock(side_effect=hook)

1141 self.connection.manager.connectors['XML'].request = xml_req_mock

1142

1143 ssh_hook = utils.SSHSideEffect()

1144 ssh_hook.append(self.vdm.output_get_interfaces_vdm(nfs_interface=''))

1145 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

1146 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1147

1148 self.assertRaises(exception.EMCVnxXMLAPIError,

1149 self.connection.setup_server,

1150 fakes.NETWORK_INFO, None)

1151

1152 if_name_1 = fakes.FakeData.network_allocations_id1[-12:]

1153 if_name_2 = fakes.FakeData.network_allocations_id2[-12:]

1154

1155 expected_calls = [

1156 mock.call(self.vdm.req_get()),

1157 mock.call(self.mover.req_get_ref()),

1158 mock.call(self.vdm.req_create()),

1159 mock.call(self.mover.req_create_interface(

1160 if_name=if_name_1,

1161 ip=fakes.FakeData.network_allocations_ip1)),

1162 mock.call(self.mover.req_create_interface(

1163 if_name=if_name_2,

1164 ip=fakes.FakeData.network_allocations_ip2)),

1165 mock.call(self.vdm.req_get()),

1166 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

1167 mock.call(self.mover.req_delete_interface(

1168 fakes.FakeData.network_allocations_ip1)),

1169 mock.call(self.vdm.req_delete()),

1170 ]

1171 xml_req_mock.assert_has_calls(expected_calls)

1172

1173 ssh_calls = [

1174 mock.call(self.vdm.cmd_get_interfaces(), False),

1175 ]

1176 ssh_cmd_mock.assert_has_calls(ssh_calls)

1177

1178 def test_teardown_server(self):

1179 hook = utils.RequestSideEffect()

1180 hook.append(self.vdm.resp_get_succeed())

1181 hook.append(self.cifs_server.resp_get_succeed(

1182 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True))

1183 hook.append(self.cifs_server.resp_task_succeed())

1184 hook.append(self.cifs_server.resp_get_succeed(

1185 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=False))

1186 hook.append(self.mover.resp_get_ref_succeed())

1187 hook.append(self.mover.resp_task_succeed())

1188 hook.append(self.mover.resp_task_succeed())

1189 hook.append(self.vdm.resp_task_succeed())

1190 xml_req_mock = utils.EMCMock(side_effect=hook)

1191 self.connection.manager.connectors['XML'].request = xml_req_mock

1192

1193 ssh_hook = utils.SSHSideEffect()

1194 ssh_hook.append(self.vdm.output_get_interfaces_vdm())

1195 ssh_hook.append()

1196 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

1197 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1198

1199 self.connection.teardown_server(fakes.SERVER_DETAIL,

1200 fakes.SECURITY_SERVICE)

1201

1202 expected_calls = [

1203 mock.call(self.vdm.req_get()),

1204 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

1205 mock.call(self.cifs_server.req_modify(

1206 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=False)),

1207 mock.call(self.cifs_server.req_delete(self.vdm.vdm_id)),

1208 mock.call(self.mover.req_get_ref()),

1209 mock.call(self.mover.req_delete_interface(

1210 fakes.FakeData.network_allocations_ip1)),

1211 mock.call(self.mover.req_delete_interface(

1212 fakes.FakeData.network_allocations_ip2)),

1213 mock.call(self.vdm.req_delete()),

1214 ]

1215 xml_req_mock.assert_has_calls(expected_calls)

1216

1217 ssh_calls = [

1218 mock.call(self.vdm.cmd_get_interfaces(), False),

1219 mock.call(self.vdm.cmd_detach_nfs_interface(), True),

1220 ]

1221 ssh_cmd_mock.assert_has_calls(ssh_calls)

1222

1223 def test_teardown_server_with_ipv6(self):

1224 hook = utils.RequestSideEffect()

1225 hook.append(self.vdm.resp_get_succeed())

1226 hook.append(self.cifs_server.resp_get_succeed(

1227 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True))

1228 hook.append(self.cifs_server.resp_task_succeed())

1229 hook.append(self.cifs_server.resp_get_succeed(

1230 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=False))

1231 hook.append(self.mover.resp_get_ref_succeed())

1232 hook.append(self.mover.resp_task_succeed())

1233 hook.append(self.mover.resp_task_succeed())

1234 hook.append(self.vdm.resp_task_succeed())

1235 xml_req_mock = utils.EMCMock(side_effect=hook)

1236 self.connection.manager.connectors['XML'].request = xml_req_mock

1237

1238 ssh_hook = utils.SSHSideEffect()

1239 ssh_hook.append(self.vdm.output_get_interfaces_vdm())

1240 ssh_hook.append()

1241 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

1242 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1243

1244 self.connection.teardown_server(fakes.SERVER_DETAIL_IPV6,

1245 fakes.SECURITY_SERVICE_IPV6)

1246

1247 expected_calls = [

1248 mock.call(self.vdm.req_get()),

1249 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

1250 mock.call(self.cifs_server.req_modify(

1251 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=False)),

1252 mock.call(self.cifs_server.req_delete(self.vdm.vdm_id)),

1253 mock.call(self.mover.req_get_ref()),

1254 mock.call(self.mover.req_delete_interface(

1255 fakes.FakeData.network_allocations_ip3)),

1256 mock.call(self.mover.req_delete_interface(

1257 fakes.FakeData.network_allocations_ip4)),

1258 mock.call(self.vdm.req_delete()),

1259 ]

1260 xml_req_mock.assert_has_calls(expected_calls)

1261

1262 ssh_calls = [

1263 mock.call(self.vdm.cmd_get_interfaces(), False),

1264 mock.call(self.vdm.cmd_detach_nfs_interface(), True),

1265 ]

1266 ssh_cmd_mock.assert_has_calls(ssh_calls)

1267

1268 def test_teardown_server_without_server_detail(self):

1269 self.connection.teardown_server(None, fakes.SECURITY_SERVICE)

1270

1271 def test_teardown_server_without_security_services(self):

1272 hook = utils.RequestSideEffect()

1273 hook.append(self.vdm.resp_get_succeed())

1274 hook.append(self.mover.resp_get_ref_succeed())

1275 hook.append(self.mover.resp_task_succeed())

1276 hook.append(self.mover.resp_task_succeed())

1277 hook.append(self.vdm.resp_task_succeed())

1278 xml_req_mock = utils.EMCMock(side_effect=hook)

1279 self.connection.manager.connectors['XML'].request = xml_req_mock

1280

1281 ssh_hook = utils.SSHSideEffect()

1282 ssh_hook.append(self.vdm.output_get_interfaces_vdm())

1283 ssh_hook.append()

1284 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

1285 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1286

1287 self.connection.teardown_server(fakes.SERVER_DETAIL, [])

1288

1289 expected_calls = [

1290 mock.call(self.vdm.req_get()),

1291 mock.call(self.mover.req_get_ref()),

1292 mock.call(self.mover.req_delete_interface(

1293 fakes.FakeData.network_allocations_ip1)),

1294 mock.call(self.mover.req_delete_interface(

1295 fakes.FakeData.network_allocations_ip2)),

1296 mock.call(self.vdm.req_delete()),

1297 ]

1298 xml_req_mock.assert_has_calls(expected_calls)

1299

1300 ssh_calls = [

1301 mock.call(self.vdm.cmd_get_interfaces(), False),

1302 mock.call(self.vdm.cmd_detach_nfs_interface(), True),

1303 ]

1304 ssh_cmd_mock.assert_has_calls(ssh_calls)

1305

1306 def test_teardown_server_without_share_server_name_in_server_detail(self):

1307 server_detail = {

1308 'cifs_if': fakes.FakeData.network_allocations_ip1,

1309 'nfs_if': fakes.FakeData.network_allocations_ip2,

1310 }

1311 self.connection.teardown_server(server_detail, fakes.SECURITY_SERVICE)

1312

1313 def test_teardown_server_with_invalid_server_name(self):

1314 hook = utils.RequestSideEffect()

1315 hook.append(self.vdm.resp_get_error())

1316 xml_req_mock = utils.EMCMock(side_effect=hook)

1317 self.connection.manager.connectors['XML'].request = xml_req_mock

1318

1319 self.connection.teardown_server(fakes.SERVER_DETAIL,

1320 fakes.SECURITY_SERVICE)

1321

1322 expected_calls = [mock.call(self.vdm.req_get())]

1323 xml_req_mock.assert_has_calls(expected_calls)

1324

1325 def test_teardown_server_without_cifs_server(self):

1326 hook = utils.RequestSideEffect()

1327 hook.append(self.vdm.resp_get_succeed())

1328 hook.append(self.cifs_server.resp_get_error())

1329 hook.append(self.mover.resp_get_ref_succeed())

1330 hook.append(self.cifs_server.resp_task_succeed())

1331 hook.append(self.cifs_server.resp_get_succeed(

1332 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=False))

1333 hook.append(self.mover.resp_task_succeed())

1334 hook.append(self.mover.resp_task_succeed())

1335 hook.append(self.vdm.resp_task_succeed())

1336 xml_req_mock = utils.EMCMock(side_effect=hook)

1337 self.connection.manager.connectors['XML'].request = xml_req_mock

1338

1339 ssh_hook = utils.SSHSideEffect()

1340 ssh_hook.append(self.vdm.output_get_interfaces_vdm())

1341 ssh_hook.append()

1342 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

1343 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1344

1345 self.connection.teardown_server(fakes.SERVER_DETAIL,

1346 fakes.SECURITY_SERVICE)

1347

1348 expected_calls = [

1349 mock.call(self.vdm.req_get()),

1350 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

1351 mock.call(self.mover.req_get_ref()),

1352 mock.call(self.mover.req_delete_interface(

1353 fakes.FakeData.network_allocations_ip1)),

1354 mock.call(self.mover.req_delete_interface(

1355 fakes.FakeData.network_allocations_ip2)),

1356 mock.call(self.vdm.req_delete()),

1357 ]

1358 xml_req_mock.assert_has_calls(expected_calls)

1359

1360 ssh_calls = [

1361 mock.call(self.vdm.cmd_get_interfaces(), False),

1362 mock.call(self.vdm.cmd_detach_nfs_interface(), True),

1363 ]

1364 ssh_cmd_mock.assert_has_calls(ssh_calls)

1365

1366 def test_teardown_server_with_invalid_cifs_server_modification(self):

1367 hook = utils.RequestSideEffect()

1368 hook.append(self.vdm.resp_get_succeed())

1369 hook.append(self.cifs_server.resp_get_succeed(

1370 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True))

1371 hook.append(self.cifs_server.resp_task_error())

1372 hook.append(self.cifs_server.resp_task_succeed())

1373 hook.append(self.mover.resp_get_ref_succeed())

1374 hook.append(self.mover.resp_task_succeed())

1375 hook.append(self.mover.resp_task_succeed())

1376 hook.append(self.vdm.resp_task_succeed())

1377 xml_req_mock = utils.EMCMock(side_effect=hook)

1378 self.connection.manager.connectors['XML'].request = xml_req_mock

1379

1380 ssh_hook = utils.SSHSideEffect()

1381 ssh_hook.append(self.vdm.output_get_interfaces_vdm())

1382 ssh_hook.append()

1383 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

1384 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1385

1386 self.connection.teardown_server(fakes.SERVER_DETAIL,

1387 fakes.SECURITY_SERVICE)

1388

1389 expected_calls = [

1390 mock.call(self.vdm.req_get()),

1391 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

1392 mock.call(self.cifs_server.req_modify(self.vdm.vdm_id)),

1393 mock.call(self.cifs_server.req_delete(self.vdm.vdm_id)),

1394 mock.call(self.mover.req_get_ref()),

1395 mock.call(self.mover.req_delete_interface(

1396 fakes.FakeData.network_allocations_ip1)),

1397 mock.call(self.mover.req_delete_interface(

1398 fakes.FakeData.network_allocations_ip2)),

1399 mock.call(self.vdm.req_delete()),

1400 ]

1401 xml_req_mock.assert_has_calls(expected_calls)

1402

1403 ssh_calls = [

1404 mock.call(self.vdm.cmd_get_interfaces(), False),

1405 mock.call(self.vdm.cmd_detach_nfs_interface(), True),

1406 ]

1407 ssh_cmd_mock.assert_has_calls(ssh_calls)

1408

1409 def test_update_access_add_cifs_rw(self):

1410 share_server = fakes.SHARE_SERVER

1411 share = fakes.CIFS_SHARE

1412 access = fakes.CIFS_RW_ACCESS

1413

1414 hook = utils.RequestSideEffect()

1415 hook.append(self.vdm.resp_get_succeed())

1416 hook.append(self.cifs_server.resp_get_succeed(

1417 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True))

1418 xml_req_mock = utils.EMCMock(side_effect=hook)

1419 self.connection.manager.connectors['XML'].request = xml_req_mock

1420

1421 ssh_hook = utils.SSHSideEffect()

1422 ssh_hook.append(self.cifs_share.output_allow_access())

1423 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

1424 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1425

1426 self.connection.update_access(None, share, [], [access], [],

1427 share_server=share_server)

1428

1429 expected_calls = [

1430 mock.call(self.vdm.req_get()),

1431 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

1432 ]

1433 xml_req_mock.assert_has_calls(expected_calls)

1434

1435 ssh_calls = [

1436 mock.call(self.cifs_share.cmd_change_access(), True),

1437 ]

1438 ssh_cmd_mock.assert_has_calls(ssh_calls)

1439

1440 def test_update_access_add_cifs_rw_with_ipv6(self):

1441 share_server = fakes.SHARE_SERVER_IPV6

1442 share = fakes.CIFS_SHARE

1443 access = fakes.CIFS_RW_ACCESS

1444

1445 hook = utils.RequestSideEffect()

1446 hook.append(self.vdm.resp_get_succeed(

1447 interface1=fakes.FakeData.interface_name3,

1448 interface2=fakes.FakeData.interface_name4))

1449 hook.append(self.cifs_server.resp_get_succeed(

1450 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True,

1451 ip_addr=fakes.FakeData.network_allocations_ip3))

1452 xml_req_mock = utils.EMCMock(side_effect=hook)

1453 self.connection.manager.connectors['XML'].request = xml_req_mock

1454

1455 ssh_hook = utils.SSHSideEffect()

1456 ssh_hook.append(self.cifs_share.output_allow_access())

1457 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

1458 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1459

1460 self.connection.update_access(None, share, [], [access], [],

1461 share_server=share_server)

1462

1463 expected_calls = [

1464 mock.call(self.vdm.req_get()),

1465 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

1466 ]

1467 xml_req_mock.assert_has_calls(expected_calls)

1468

1469 ssh_calls = [

1470 mock.call(self.cifs_share.cmd_change_access(), True),

1471 ]

1472 ssh_cmd_mock.assert_has_calls(ssh_calls)

1473

1474 def test_update_access_deny_nfs(self):

1475 share_server = fakes.SHARE_SERVER

1476 share = fakes.NFS_SHARE

1477 access = fakes.NFS_RW_ACCESS

1478

1479 rw_hosts = copy.deepcopy(fakes.FakeData.rw_hosts)

1480 rw_hosts.append(access['access_to'])

1481

1482 ssh_hook = utils.SSHSideEffect()

1483 ssh_hook.append(self.nfs_share.output_get_succeed(

1484 rw_hosts=rw_hosts,

1485 ro_hosts=fakes.FakeData.ro_hosts))

1486 ssh_hook.append(self.nfs_share.output_set_access_success())

1487 ssh_hook.append(self.nfs_share.output_get_succeed(

1488 rw_hosts=fakes.FakeData.rw_hosts,

1489 ro_hosts=fakes.FakeData.ro_hosts))

1490 ssh_cmd_mock = utils.EMCNFSShareMock(side_effect=ssh_hook)

1491 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1492

1493 self.connection.update_access(None, share, [], [], [access],

1494 share_server=share_server)

1495

1496 ssh_calls = [

1497 mock.call(self.nfs_share.cmd_get(), True),

1498 mock.call(self.nfs_share.cmd_set_access(

1499 rw_hosts=self.nfs_share.rw_hosts,

1500 ro_hosts=self.nfs_share.ro_hosts), True),

1501 mock.call(self.nfs_share.cmd_get(), True),

1502 ]

1503 ssh_cmd_mock.assert_has_calls(ssh_calls)

1504

1505 def test_update_access_deny_nfs_with_ipv6(self):

1506 share_server = fakes.SHARE_SERVER_IPV6

1507 share = fakes.NFS_SHARE

1508 access = fakes.NFS_RW_ACCESS

1509

1510 rw_hosts = copy.deepcopy(fakes.FakeData.rw_hosts_ipv6)

1511 rw_hosts.append(access['access_to'])

1512

1513 ssh_hook = utils.SSHSideEffect()

1514 ssh_hook.append(self.nfs_share.output_get_succeed(

1515 rw_hosts=rw_hosts,

1516 ro_hosts=fakes.FakeData.ro_hosts_ipv6))

1517 ssh_hook.append(self.nfs_share.output_set_access_success())

1518 ssh_hook.append(self.nfs_share.output_get_succeed(

1519 rw_hosts=fakes.FakeData.rw_hosts_ipv6,

1520 ro_hosts=fakes.FakeData.ro_hosts_ipv6))

1521 ssh_cmd_mock = utils.EMCNFSShareMock(side_effect=ssh_hook)

1522 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1523

1524 self.connection.update_access(None, share, [], [], [access],

1525 share_server=share_server)

1526

1527 ssh_calls = [

1528 mock.call(self.nfs_share.cmd_get(), True),

1529 mock.call(self.nfs_share.cmd_set_access(

1530 rw_hosts=self.nfs_share.rw_hosts_ipv6,

1531 ro_hosts=self.nfs_share.ro_hosts_ipv6), True),

1532 mock.call(self.nfs_share.cmd_get(), True),

1533 ]

1534 ssh_cmd_mock.assert_has_calls(ssh_calls)

1535

1536 def test_update_access_recover_nfs_rule(self):

1537 share_server = fakes.SHARE_SERVER

1538 share = fakes.NFS_SHARE

1539 access = fakes.NFS_RW_ACCESS

1540 hosts = ['192.168.1.5']

1541

1542 rw_hosts = copy.deepcopy(fakes.FakeData.rw_hosts)

1543 rw_hosts.append(access['access_to'])

1544

1545 ssh_hook = utils.SSHSideEffect()

1546 ssh_hook.append(self.nfs_share.output_get_succeed(

1547 rw_hosts=rw_hosts,

1548 ro_hosts=fakes.FakeData.ro_hosts))

1549 ssh_hook.append(self.nfs_share.output_set_access_success())

1550 ssh_hook.append(self.nfs_share.output_get_succeed(

1551 rw_hosts=hosts,

1552 ro_hosts=[]))

1553 ssh_cmd_mock = utils.EMCNFSShareMock(side_effect=ssh_hook)

1554 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1555

1556 self.connection.update_access(None, share, [access], [], [],

1557 share_server=share_server)

1558

1559 ssh_calls = [

1560 mock.call(self.nfs_share.cmd_get(), True),

1561 mock.call(self.nfs_share.cmd_set_access(

1562 rw_hosts=hosts,

1563 ro_hosts=[]), True),

1564 mock.call(self.nfs_share.cmd_get(), True),

1565 ]

1566 ssh_cmd_mock.assert_has_calls(ssh_calls)

1567

1568 def test_update_access_recover_nfs_rule_with_ipv6(self):

1569 share_server = fakes.SHARE_SERVER_IPV6

1570 share = fakes.NFS_SHARE

1571 access = fakes.NFS_RW_ACCESS_IPV6

1572 hosts = ['fdf8:f53b:82e1::5']

1573

1574 rw_hosts = copy.deepcopy(fakes.FakeData.rw_hosts_ipv6)

1575 rw_hosts.append(access['access_to'])

1576

1577 ssh_hook = utils.SSHSideEffect()

1578 ssh_hook.append(self.nfs_share.output_get_succeed(

1579 rw_hosts=rw_hosts,

1580 ro_hosts=fakes.FakeData.ro_hosts_ipv6))

1581 ssh_hook.append(self.nfs_share.output_set_access_success())

1582 ssh_hook.append(self.nfs_share.output_get_succeed(

1583 rw_hosts=hosts,

1584 ro_hosts=[]))

1585 ssh_cmd_mock = utils.EMCNFSShareMock(side_effect=ssh_hook)

1586 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1587

1588 self.connection.update_access(None, share, [access], [], [],

1589 share_server=share_server)

1590

1591 ssh_calls = [

1592 mock.call(self.nfs_share.cmd_get(), True),

1593 mock.call(self.nfs_share.cmd_set_access(

1594 rw_hosts=hosts,

1595 ro_hosts=[]), True),

1596 mock.call(self.nfs_share.cmd_get(), True),

1597 ]

1598 ssh_cmd_mock.assert_has_calls(ssh_calls)

1599

1600 def test_update_access_recover_cifs_rule(self):

1601 share_server = fakes.SHARE_SERVER

1602 share = fakes.CIFS_SHARE

1603 access = fakes.CIFS_RW_ACCESS

1604

1605 hook = utils.RequestSideEffect()

1606 hook.append(self.vdm.resp_get_succeed())

1607 hook.append(self.cifs_server.resp_get_succeed(

1608 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True))

1609 xml_req_mock = utils.EMCMock(side_effect=hook)

1610 self.connection.manager.connectors['XML'].request = xml_req_mock

1611

1612 ssh_hook = utils.SSHSideEffect()

1613 ssh_hook.append(self.cifs_share.output_allow_access())

1614 ssh_hook.append(fakes.FakeData.cifs_access)

1615 ssh_hook.append('Command succeeded')

1616

1617 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

1618 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1619

1620 self.connection.update_access(None, share, [access], [], [],

1621 share_server=share_server)

1622

1623 expected_calls = [

1624 mock.call(self.vdm.req_get()),

1625 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

1626 ]

1627 xml_req_mock.assert_has_calls(expected_calls)

1628

1629 ssh_calls = [

1630 mock.call(self.cifs_share.cmd_change_access(), True),

1631 mock.call(self.cifs_share.cmd_get_access(), True),

1632 mock.call(self.cifs_share.cmd_change_access(

1633 action='revoke', user='guest'), True),

1634 ]

1635 ssh_cmd_mock.assert_has_calls(ssh_calls)

1636

1637 def test_update_access_recover_cifs_rule_with_ipv6(self):

1638 share_server = fakes.SHARE_SERVER_IPV6

1639 share = fakes.CIFS_SHARE

1640 access = fakes.CIFS_RW_ACCESS

1641

1642 hook = utils.RequestSideEffect()

1643 hook.append(self.vdm.resp_get_succeed(

1644 interface1=fakes.FakeData.interface_name3,

1645 interface2=fakes.FakeData.interface_name4))

1646 hook.append(self.cifs_server.resp_get_succeed(

1647 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True,

1648 ip_addr=fakes.FakeData.network_allocations_ip3))

1649 xml_req_mock = utils.EMCMock(side_effect=hook)

1650 self.connection.manager.connectors['XML'].request = xml_req_mock

1651

1652 ssh_hook = utils.SSHSideEffect()

1653 ssh_hook.append(self.cifs_share.output_allow_access())

1654 ssh_hook.append(fakes.FakeData.cifs_access)

1655 ssh_hook.append('Command succeeded')

1656

1657 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

1658 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1659

1660 self.connection.update_access(None, share, [access], [], [],

1661 share_server=share_server)

1662

1663 expected_calls = [

1664 mock.call(self.vdm.req_get()),

1665 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

1666 ]

1667 xml_req_mock.assert_has_calls(expected_calls)

1668

1669 ssh_calls = [

1670 mock.call(self.cifs_share.cmd_change_access(), True),

1671 mock.call(self.cifs_share.cmd_get_access(), True),

1672 mock.call(self.cifs_share.cmd_change_access(

1673 action='revoke', user='guest'), True),

1674 ]

1675 ssh_cmd_mock.assert_has_calls(ssh_calls)

1676

1677 def test_cifs_clear_access_server_not_found(self):

1678 server = fakes.SHARE_SERVER

1679

1680 hook = utils.RequestSideEffect()

1681 hook.append(self.vdm.resp_get_succeed())

1682 hook.append(self.cifs_server.resp_get_succeed(

1683 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True,

1684 cifs_server_name='cifs_server_name'))

1685 xml_req_mock = utils.EMCMock(side_effect=hook)

1686 self.connection.manager.connectors['XML'].request = xml_req_mock

1687

1688 self.assertRaises(exception.EMCVnxXMLAPIError,

1689 self.connection._cifs_clear_access,

1690 'share_name', server, None)

1691

1692 expected_calls = [

1693 mock.call(self.vdm.req_get()),

1694 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

1695 ]

1696 xml_req_mock.assert_has_calls(expected_calls)

1697

1698 def test_allow_cifs_rw_access(self):

1699 share_server = fakes.SHARE_SERVER

1700 share = fakes.CIFS_SHARE

1701 access = fakes.CIFS_RW_ACCESS

1702

1703 hook = utils.RequestSideEffect()

1704 hook.append(self.vdm.resp_get_succeed())

1705 hook.append(self.cifs_server.resp_get_succeed(

1706 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True))

1707 xml_req_mock = utils.EMCMock(side_effect=hook)

1708 self.connection.manager.connectors['XML'].request = xml_req_mock

1709

1710 ssh_hook = utils.SSHSideEffect()

1711 ssh_hook.append(self.cifs_share.output_allow_access())

1712 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

1713 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1714

1715 self.connection.allow_access(None, share, access, share_server)

1716

1717 expected_calls = [

1718 mock.call(self.vdm.req_get()),

1719 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

1720 ]

1721 xml_req_mock.assert_has_calls(expected_calls)

1722

1723 ssh_calls = [

1724 mock.call(self.cifs_share.cmd_change_access(), True),

1725 ]

1726 ssh_cmd_mock.assert_has_calls(ssh_calls)

1727

1728 def test_allow_cifs_rw_access_with_ipv6(self):

1729 share_server = fakes.SHARE_SERVER_IPV6

1730 share = fakes.CIFS_SHARE

1731 access = fakes.CIFS_RW_ACCESS

1732

1733 hook = utils.RequestSideEffect()

1734 hook.append(self.vdm.resp_get_succeed(

1735 interface1=fakes.FakeData.interface_name3,

1736 interface2=fakes.FakeData.interface_name4))

1737 hook.append(self.cifs_server.resp_get_succeed(

1738 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True,

1739 ip_addr=fakes.FakeData.network_allocations_ip3))

1740 xml_req_mock = utils.EMCMock(side_effect=hook)

1741 self.connection.manager.connectors['XML'].request = xml_req_mock

1742

1743 ssh_hook = utils.SSHSideEffect()

1744 ssh_hook.append(self.cifs_share.output_allow_access())

1745 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

1746 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1747

1748 self.connection.allow_access(None, share, access, share_server)

1749

1750 expected_calls = [

1751 mock.call(self.vdm.req_get()),

1752 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

1753 ]

1754 xml_req_mock.assert_has_calls(expected_calls)

1755

1756 ssh_calls = [

1757 mock.call(self.cifs_share.cmd_change_access(), True),

1758 ]

1759 ssh_cmd_mock.assert_has_calls(ssh_calls)

1760

1761 def test_allow_cifs_ro_access(self):

1762 share_server = fakes.SHARE_SERVER

1763 share = fakes.CIFS_SHARE

1764 access = fakes.CIFS_RO_ACCESS

1765

1766 hook = utils.RequestSideEffect()

1767 hook.append(self.vdm.resp_get_succeed())

1768 hook.append(self.cifs_server.resp_get_succeed(

1769 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True))

1770 xml_req_mock = utils.EMCMock(side_effect=hook)

1771 self.connection.manager.connectors['XML'].request = xml_req_mock

1772

1773 ssh_hook = utils.SSHSideEffect()

1774 ssh_hook.append(self.cifs_share.output_allow_access())

1775 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

1776 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1777

1778 self.connection.allow_access(None, share, access, share_server)

1779

1780 expected_calls = [

1781 mock.call(self.vdm.req_get()),

1782 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

1783 ]

1784 xml_req_mock.assert_has_calls(expected_calls)

1785

1786 ssh_calls = [

1787 mock.call(self.cifs_share.cmd_change_access('ro'), True),

1788 ]

1789 ssh_cmd_mock.assert_has_calls(ssh_calls)

1790

1791 def test_allow_cifs_ro_access_with_ipv6(self):

1792 share_server = fakes.SHARE_SERVER_IPV6

1793 share = fakes.CIFS_SHARE

1794 access = fakes.CIFS_RO_ACCESS

1795

1796 hook = utils.RequestSideEffect()

1797 hook.append(self.vdm.resp_get_succeed(

1798 interface1=fakes.FakeData.interface_name3,

1799 interface2=fakes.FakeData.interface_name4))

1800 hook.append(self.cifs_server.resp_get_succeed(

1801 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True,

1802 ip_addr=fakes.FakeData.network_allocations_ip3))

1803 xml_req_mock = utils.EMCMock(side_effect=hook)

1804 self.connection.manager.connectors['XML'].request = xml_req_mock

1805

1806 ssh_hook = utils.SSHSideEffect()

1807 ssh_hook.append(self.cifs_share.output_allow_access())

1808 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

1809 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1810

1811 self.connection.allow_access(None, share, access, share_server)

1812

1813 expected_calls = [

1814 mock.call(self.vdm.req_get()),

1815 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

1816 ]

1817 xml_req_mock.assert_has_calls(expected_calls)

1818

1819 ssh_calls = [

1820 mock.call(self.cifs_share.cmd_change_access('ro'), True),

1821 ]

1822 ssh_cmd_mock.assert_has_calls(ssh_calls)

1823

1824 def test_allow_ro_access_without_share_server_name(self):

1825 share = fakes.CIFS_SHARE

1826 share_server = copy.deepcopy(fakes.SHARE_SERVER)

1827 share_server['backend_details'].pop('share_server_name')

1828 access = fakes.CIFS_RO_ACCESS

1829

1830 hook = utils.RequestSideEffect()

1831 hook.append(self.vdm.resp_get_succeed())

1832 hook.append(self.cifs_server.resp_get_succeed(

1833 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True))

1834 xml_req_mock = utils.EMCMock(side_effect=hook)

1835 self.connection.manager.connectors['XML'].request = xml_req_mock

1836

1837 ssh_hook = utils.SSHSideEffect()

1838 ssh_hook.append(self.cifs_share.output_allow_access())

1839 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

1840 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1841

1842 self.connection.allow_access(None, share, access, share_server)

1843

1844 expected_calls = [

1845 mock.call(self.vdm.req_get()),

1846 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

1847 ]

1848 xml_req_mock.assert_has_calls(expected_calls)

1849

1850 ssh_calls = [

1851 mock.call(self.cifs_share.cmd_change_access('ro'), True),

1852 ]

1853 ssh_cmd_mock.assert_has_calls(ssh_calls)

1854

1855 def test_allow_access_with_invalid_access_level(self):

1856 share_server = fakes.SHARE_SERVER

1857 share = fakes.CIFS_SHARE

1858 access = fake_share.fake_access(access_level='fake_level')

1859

1860 self.assertRaises(exception.InvalidShareAccessLevel,

1861 self.connection.allow_access,

1862 None, share, access, share_server)

1863

1864 def test_allow_access_with_invalid_share_server_name(self):

1865 share_server = fakes.SHARE_SERVER

1866 share = fakes.CIFS_SHARE

1867 access = fakes.CIFS_RW_ACCESS

1868

1869 hook = utils.RequestSideEffect()

1870 hook.append(self.vdm.resp_get_succeed())

1871 hook.append(self.cifs_server.resp_get_error())

1872 xml_req_mock = utils.EMCMock(side_effect=hook)

1873 self.connection.manager.connectors['XML'].request = xml_req_mock

1874

1875 self.assertRaises(exception.EMCVnxXMLAPIError,

1876 self.connection.allow_access,

1877 None, share, access, share_server)

1878

1879 expected_calls = [

1880 mock.call(self.vdm.req_get()),

1881 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

1882 ]

1883 xml_req_mock.assert_has_calls(expected_calls)

1884

1885 def test_allow_nfs_access(self):

1886 share_server = fakes.SHARE_SERVER

1887 share = fakes.NFS_SHARE

1888 access = fakes.NFS_RW_ACCESS

1889

1890 rw_hosts = copy.deepcopy(fakes.FakeData.rw_hosts)

1891 rw_hosts.append(access['access_to'])

1892

1893 ssh_hook = utils.SSHSideEffect()

1894 ssh_hook.append(self.nfs_share.output_get_succeed(

1895 rw_hosts=fakes.FakeData.rw_hosts,

1896 ro_hosts=fakes.FakeData.ro_hosts))

1897 ssh_hook.append(self.nfs_share.output_set_access_success())

1898 ssh_hook.append(self.nfs_share.output_get_succeed(

1899 rw_hosts=rw_hosts,

1900 ro_hosts=fakes.FakeData.ro_hosts))

1901 ssh_cmd_mock = utils.EMCNFSShareMock(side_effect=ssh_hook)

1902 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1903

1904 self.connection.allow_access(None, share, access, share_server)

1905

1906 ssh_calls = [

1907 mock.call(self.nfs_share.cmd_get(), True),

1908 mock.call(self.nfs_share.cmd_set_access(

1909 rw_hosts=rw_hosts, ro_hosts=self.nfs_share.ro_hosts), True),

1910 mock.call(self.nfs_share.cmd_get(), True),

1911 ]

1912 ssh_cmd_mock.assert_has_calls(ssh_calls)

1913

1914 def test_allow_nfs_access_with_ipv6(self):

1915 share_server = fakes.SHARE_SERVER_IPV6

1916 share = fakes.NFS_SHARE

1917 access = fakes.NFS_RW_ACCESS_IPV6

1918

1919 rw_hosts = copy.deepcopy(fakes.FakeData.rw_hosts_ipv6)

1920 rw_hosts.append(access['access_to'])

1921

1922 ssh_hook = utils.SSHSideEffect()

1923 ssh_hook.append(self.nfs_share.output_get_succeed(

1924 rw_hosts=fakes.FakeData.rw_hosts_ipv6,

1925 ro_hosts=fakes.FakeData.ro_hosts_ipv6))

1926 ssh_hook.append(self.nfs_share.output_set_access_success())

1927 ssh_hook.append(self.nfs_share.output_get_succeed(

1928 rw_hosts=rw_hosts,

1929 ro_hosts=fakes.FakeData.ro_hosts_ipv6))

1930 ssh_cmd_mock = utils.EMCNFSShareMock(side_effect=ssh_hook)

1931 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1932

1933 self.connection.allow_access(None, share, access, share_server)

1934

1935 ssh_calls = [

1936 mock.call(self.nfs_share.cmd_get(), True),

1937 mock.call(self.nfs_share.cmd_set_access(

1938 rw_hosts=rw_hosts,

1939 ro_hosts=self.nfs_share.ro_hosts_ipv6),

1940 True),

1941 mock.call(self.nfs_share.cmd_get(), True),

1942 ]

1943 ssh_cmd_mock.assert_has_calls(ssh_calls)

1944

1945 def test_allow_cifs_access_with_incorrect_access_type(self):

1946 share_server = fakes.SHARE_SERVER

1947 share = fakes.CIFS_SHARE

1948 access = fake_share.fake_access(access_type='fake_type')

1949

1950 self.assertRaises(exception.InvalidShareAccess,

1951 self.connection.allow_access,

1952 None, share, access, share_server)

1953

1954 def test_allow_nfs_access_with_incorrect_access_type(self):

1955 share_server = fakes.SHARE_SERVER

1956 share = fakes.NFS_SHARE

1957 access = fake_share.fake_access(access_type='fake_type')

1958

1959 self.assertRaises(exception.InvalidShareAccess,

1960 self.connection.allow_access,

1961 None, share, access, share_server)

1962

1963 def test_allow_access_with_incorrect_proto(self):

1964 share_server = fakes.SHARE_SERVER

1965 share = fake_share.fake_share(share_proto='FAKE_PROTO')

1966 access = fake_share.fake_access()

1967

1968 self.assertRaises(exception.InvalidShare,

1969 self.connection.allow_access,

1970 None, share, access, share_server)

1971

1972 def test_deny_cifs_rw_access(self):

1973 share_server = fakes.SHARE_SERVER

1974 share = fakes.CIFS_SHARE

1975 access = fakes.CIFS_RW_ACCESS

1976

1977 hook = utils.RequestSideEffect()

1978 hook.append(self.vdm.resp_get_succeed())

1979 hook.append(self.cifs_server.resp_get_succeed(

1980 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True))

1981 xml_req_mock = utils.EMCMock(side_effect=hook)

1982 self.connection.manager.connectors['XML'].request = xml_req_mock

1983

1984 ssh_hook = utils.SSHSideEffect()

1985 ssh_hook.append(self.cifs_share.output_allow_access())

1986 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

1987 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

1988

1989 self.connection.deny_access(None, share, access, share_server)

1990

1991 expected_calls = [

1992 mock.call(self.vdm.req_get()),

1993 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

1994 ]

1995 xml_req_mock.assert_has_calls(expected_calls)

1996

1997 ssh_calls = [

1998 mock.call(self.cifs_share.cmd_change_access(action='revoke'),

1999 True),

2000 ]

2001 ssh_cmd_mock.assert_has_calls(ssh_calls)

2002

2003 def test_deny_cifs_rw_access_with_ipv6(self):

2004 share_server = fakes.SHARE_SERVER_IPV6

2005 share = fakes.CIFS_SHARE

2006 access = fakes.CIFS_RW_ACCESS

2007

2008 hook = utils.RequestSideEffect()

2009 hook.append(self.vdm.resp_get_succeed(

2010 interface1=fakes.FakeData.interface_name3,

2011 interface2=fakes.FakeData.interface_name4))

2012 hook.append(self.cifs_server.resp_get_succeed(

2013 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True,

2014 ip_addr=fakes.FakeData.network_allocations_ip3))

2015 xml_req_mock = utils.EMCMock(side_effect=hook)

2016 self.connection.manager.connectors['XML'].request = xml_req_mock

2017

2018 ssh_hook = utils.SSHSideEffect()

2019 ssh_hook.append(self.cifs_share.output_allow_access())

2020 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

2021 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

2022

2023 self.connection.deny_access(None, share, access, share_server)

2024

2025 expected_calls = [

2026 mock.call(self.vdm.req_get()),

2027 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

2028 ]

2029 xml_req_mock.assert_has_calls(expected_calls)

2030

2031 ssh_calls = [

2032 mock.call(self.cifs_share.cmd_change_access(action='revoke'),

2033 True),

2034 ]

2035 ssh_cmd_mock.assert_has_calls(ssh_calls)

2036

2037 def test_deny_cifs_ro_access(self):

2038 share_server = fakes.SHARE_SERVER

2039 share = fakes.CIFS_SHARE

2040 access = fakes.CIFS_RO_ACCESS

2041

2042 hook = utils.RequestSideEffect()

2043 hook.append(self.vdm.resp_get_succeed())

2044 hook.append(self.cifs_server.resp_get_succeed(

2045 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True))

2046 xml_req_mock = utils.EMCMock(side_effect=hook)

2047 self.connection.manager.connectors['XML'].request = xml_req_mock

2048

2049 ssh_hook = utils.SSHSideEffect()

2050 ssh_hook.append(self.cifs_share.output_allow_access())

2051 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

2052 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

2053

2054 self.connection.deny_access(None, share, access, share_server)

2055

2056 expected_calls = [

2057 mock.call(self.vdm.req_get()),

2058 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

2059 ]

2060 xml_req_mock.assert_has_calls(expected_calls)

2061

2062 ssh_calls = [

2063 mock.call(self.cifs_share.cmd_change_access('ro', 'revoke'), True),

2064 ]

2065 ssh_cmd_mock.assert_has_calls(ssh_calls)

2066

2067 def test_deny_cifs_ro_access_with_ipv6(self):

2068 share_server = fakes.SHARE_SERVER_IPV6

2069 share = fakes.CIFS_SHARE

2070 access = fakes.CIFS_RO_ACCESS

2071

2072 hook = utils.RequestSideEffect()

2073 hook.append(self.vdm.resp_get_succeed(

2074 interface1=fakes.FakeData.interface_name3,

2075 interface2=fakes.FakeData.interface_name4))

2076 hook.append(self.cifs_server.resp_get_succeed(

2077 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True,

2078 ip_addr=fakes.FakeData.network_allocations_ip3))

2079 xml_req_mock = utils.EMCMock(side_effect=hook)

2080 self.connection.manager.connectors['XML'].request = xml_req_mock

2081

2082 ssh_hook = utils.SSHSideEffect()

2083 ssh_hook.append(self.cifs_share.output_allow_access())

2084 ssh_cmd_mock = mock.Mock(side_effect=ssh_hook)

2085 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

2086

2087 self.connection.deny_access(None, share, access, share_server)

2088

2089 expected_calls = [

2090 mock.call(self.vdm.req_get()),

2091 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

2092 ]

2093 xml_req_mock.assert_has_calls(expected_calls)

2094

2095 ssh_calls = [

2096 mock.call(self.cifs_share.cmd_change_access('ro', 'revoke'), True),

2097 ]

2098 ssh_cmd_mock.assert_has_calls(ssh_calls)

2099

2100 def test_deny_cifs_access_with_invliad_share_server_name(self):

2101 share_server = fakes.SHARE_SERVER

2102 share = fakes.CIFS_SHARE

2103 access = fakes.CIFS_RW_ACCESS

2104

2105 hook = utils.RequestSideEffect()

2106 hook.append(self.vdm.resp_get_succeed())

2107 hook.append(self.cifs_server.resp_get_error())

2108 xml_req_mock = utils.EMCMock(side_effect=hook)

2109 self.connection.manager.connectors['XML'].request = xml_req_mock

2110

2111 self.assertRaises(exception.EMCVnxXMLAPIError,

2112 self.connection.deny_access,

2113 None, share, access, share_server)

2114

2115 expected_calls = [

2116 mock.call(self.vdm.req_get()),

2117 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

2118 ]

2119 xml_req_mock.assert_has_calls(expected_calls)

2120

2121 def test_deny_nfs_access(self):

2122 share_server = fakes.SHARE_SERVER

2123 share = fakes.NFS_SHARE

2124 access = fakes.NFS_RW_ACCESS

2125

2126 rw_hosts = copy.deepcopy(fakes.FakeData.rw_hosts)

2127 rw_hosts.append(access['access_to'])

2128

2129 ssh_hook = utils.SSHSideEffect()

2130 ssh_hook.append(self.nfs_share.output_get_succeed(

2131 rw_hosts=rw_hosts,

2132 ro_hosts=fakes.FakeData.ro_hosts))

2133 ssh_hook.append(self.nfs_share.output_set_access_success())

2134 ssh_hook.append(self.nfs_share.output_get_succeed(

2135 rw_hosts=fakes.FakeData.rw_hosts,

2136 ro_hosts=fakes.FakeData.ro_hosts))

2137 ssh_cmd_mock = utils.EMCNFSShareMock(side_effect=ssh_hook)

2138 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

2139

2140 self.connection.deny_access(None, share, access, share_server)

2141

2142 ssh_calls = [

2143 mock.call(self.nfs_share.cmd_get(), True),

2144 mock.call(self.nfs_share.cmd_set_access(

2145 rw_hosts=self.nfs_share.rw_hosts,

2146 ro_hosts=self.nfs_share.ro_hosts), True),

2147 mock.call(self.nfs_share.cmd_get(), True),

2148 ]

2149 ssh_cmd_mock.assert_has_calls(ssh_calls)

2150

2151 def test_deny_nfs_access_with_ipv6(self):

2152 share_server = fakes.SHARE_SERVER_IPV6

2153 share = fakes.NFS_SHARE

2154 access = fakes.NFS_RW_ACCESS_IPV6

2155

2156 rw_hosts = copy.deepcopy(fakes.FakeData.rw_hosts_ipv6)

2157 rw_hosts.append(access['access_to'])

2158

2159 ssh_hook = utils.SSHSideEffect()

2160 ssh_hook.append(self.nfs_share.output_get_succeed(

2161 rw_hosts=rw_hosts,

2162 ro_hosts=fakes.FakeData.ro_hosts_ipv6))

2163 ssh_hook.append(self.nfs_share.output_set_access_success())

2164 ssh_hook.append(self.nfs_share.output_get_succeed(

2165 rw_hosts=fakes.FakeData.rw_hosts_ipv6,

2166 ro_hosts=fakes.FakeData.ro_hosts_ipv6))

2167 ssh_cmd_mock = utils.EMCNFSShareMock(side_effect=ssh_hook)

2168 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

2169

2170 self.connection.deny_access(None, share, access, share_server)

2171

2172 ssh_calls = [

2173 mock.call(self.nfs_share.cmd_get(), True),

2174 mock.call(self.nfs_share.cmd_set_access(

2175 rw_hosts=self.nfs_share.rw_hosts_ipv6,

2176 ro_hosts=self.nfs_share.ro_hosts_ipv6), True),

2177 mock.call(self.nfs_share.cmd_get(), True),

2178 ]

2179 ssh_cmd_mock.assert_has_calls(ssh_calls)

2180

2181 def test_deny_access_with_incorrect_proto(self):

2182 share_server = fakes.SHARE_SERVER

2183 share = fake_share.fake_share(share_proto='FAKE_PROTO')

2184 access = fakes.CIFS_RW_ACCESS

2185

2186 self.assertRaises(exception.InvalidShare,

2187 self.connection.deny_access,

2188 None, share, access, share_server)

2189

2190 def test_deny_cifs_access_with_incorrect_access_type(self):

2191 share_server = fakes.SHARE_SERVER

2192 share = fakes.CIFS_SHARE

2193 access = fake_share.fake_access(access_type='fake_type')

2194

2195 self.assertRaises(exception.InvalidShareAccess,

2196 self.connection.deny_access,

2197 None, share, access, share_server)

2198

2199 def test_deny_nfs_access_with_incorrect_access_type(self):

2200 share_server = fakes.SHARE_SERVER

2201 share = fakes.NFS_SHARE

2202 access = fake_share.fake_access(access_type='fake_type')

2203

2204 self.assertRaises(exception.InvalidShareAccess,

2205 self.connection.deny_access,

2206 None, share, access, share_server)

2207

2208 def test_update_share_stats(self):

2209 hook = utils.RequestSideEffect()

2210 hook.append(self.mover.resp_get_ref_succeed())

2211 hook.append(self.pool.resp_get_succeed())

2212 xml_req_mock = utils.EMCMock(side_effect=hook)

2213 self.connection.manager.connectors['XML'].request = xml_req_mock

2214

2215 self.connection.update_share_stats(fakes.STATS)

2216

2217 expected_calls = [

2218 mock.call(self.mover.req_get_ref()),

2219 mock.call(self.pool.req_get()),

2220 ]

2221 xml_req_mock.assert_has_calls(expected_calls)

2222

2223 for pool in fakes.STATS['pools']:

2224 if pool['pool_name'] == fakes.FakeData.pool_name:

2225 self.assertEqual(

2226 enas_utils.mb_to_gb(fakes.FakeData.pool_total_size),

2227 pool['total_capacity_gb'])

2228

2229 free_size = (fakes.FakeData.pool_total_size -

2230 fakes.FakeData.pool_used_size)

2231 self.assertEqual(enas_utils.mb_to_gb(free_size),

2232 pool['free_capacity_gb'])

2233

2234 def test_update_share_stats_without_matched_config_pools(self):

2235 self.connection.pools = set('fake_pool')

2236

2237 hook = utils.RequestSideEffect()

2238 hook.append(self.mover.resp_get_ref_succeed())

2239 hook.append(self.pool.resp_get_succeed())

2240 xml_req_mock = utils.EMCMock(side_effect=hook)

2241 self.connection.manager.connectors['XML'].request = xml_req_mock

2242

2243 self.assertRaises(exception.EMCVnxXMLAPIError,

2244 self.connection.update_share_stats,

2245 fakes.STATS)

2246

2247 expected_calls = [

2248 mock.call(self.mover.req_get_ref()),

2249 mock.call(self.pool.req_get()),

2250 ]

2251 xml_req_mock.assert_has_calls(expected_calls)

2252

2253 def test_get_pool(self):

2254 share = fakes.CIFS_SHARE

2255

2256 hook = utils.RequestSideEffect()

2257 hook.append(self.fs.resp_get_succeed())

2258 hook.append(self.pool.resp_get_succeed())

2259 xml_req_mock = utils.EMCMock(side_effect=hook)

2260 self.connection.manager.connectors['XML'].request = xml_req_mock

2261

2262 pool_name = self.connection.get_pool(share)

2263

2264 expected_calls = [

2265 mock.call(self.fs.req_get()),

2266 mock.call(self.pool.req_get()),

2267 ]

2268 xml_req_mock.assert_has_calls(expected_calls)

2269

2270 self.assertEqual(fakes.FakeData.pool_name, pool_name)

2271

2272 def test_get_pool_failed_to_get_filesystem_info(self):

2273 share = fakes.CIFS_SHARE

2274

2275 hook = utils.RequestSideEffect()

2276 hook.append(self.fs.resp_get_error())

2277 xml_req_mock = utils.EMCMock(side_effect=hook)

2278 self.connection.manager.connectors['XML'].request = xml_req_mock

2279

2280 self.assertRaises(exception.EMCVnxXMLAPIError,

2281 self.connection.get_pool,

2282 share)

2283

2284 expected_calls = [mock.call(self.fs.req_get())]

2285 xml_req_mock.assert_has_calls(expected_calls)

2286

2287 def test_get_pool_failed_to_get_pool_info(self):

2288 share = fakes.CIFS_SHARE

2289

2290 hook = utils.RequestSideEffect()

2291 hook.append(self.fs.resp_get_succeed())

2292 hook.append(self.pool.resp_get_error())

2293 xml_req_mock = utils.EMCMock(side_effect=hook)

2294 self.connection.manager.connectors['XML'].request = xml_req_mock

2295

2296 self.assertRaises(exception.EMCVnxXMLAPIError,

2297 self.connection.get_pool,

2298 share)

2299

2300 expected_calls = [

2301 mock.call(self.fs.req_get()),

2302 mock.call(self.pool.req_get()),

2303 ]

2304 xml_req_mock.assert_has_calls(expected_calls)

2305

2306 def test_get_pool_failed_to_find_matched_pool_name(self):

2307 share = fakes.CIFS_SHARE

2308

2309 hook = utils.RequestSideEffect()

2310 hook.append(self.fs.resp_get_succeed())

2311 hook.append(self.pool.resp_get_succeed(name='unmatch_pool_name',

2312 id='unmatch_pool_id'))

2313 xml_req_mock = utils.EMCMock(side_effect=hook)

2314 self.connection.manager.connectors['XML'].request = xml_req_mock

2315

2316 self.assertRaises(exception.EMCVnxXMLAPIError,

2317 self.connection.get_pool,

2318 share)

2319

2320 expected_calls = [

2321 mock.call(self.fs.req_get()),

2322 mock.call(self.pool.req_get()),

2323 ]

2324 xml_req_mock.assert_has_calls(expected_calls)

2325

2326 @ddt.data({'port_conf': None,

2327 'managed_ports': ['cge-1-0', 'cge-1-3']},

2328 {'port_conf': '*',

2329 'managed_ports': ['cge-1-0', 'cge-1-3']},

2330 {'port_conf': ['cge-1-*'],

2331 'managed_ports': ['cge-1-0', 'cge-1-3']},

2332 {'port_conf': ['cge-1-3'],

2333 'managed_ports': ['cge-1-3']})

2334 @ddt.unpack

2335 def test_get_managed_ports_one_port(self, port_conf, managed_ports):

2336 hook = utils.SSHSideEffect()

2337 hook.append(self.mover.output_get_physical_devices())

2338

2339 ssh_cmd_mock = mock.Mock(side_effect=hook)

2340 expected_calls = [

2341 mock.call(self.mover.cmd_get_physical_devices(), False),

2342 ]

2343 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

2344 self.connection.port_conf = port_conf

2345 ports = self.connection.get_managed_ports()

2346 self.assertIsInstance(ports, list)

2347 self.assertEqual(sorted(managed_ports), sorted(ports))

2348 ssh_cmd_mock.assert_has_calls(expected_calls)

2349

2350 def test_get_managed_ports_no_valid_port(self):

2351 hook = utils.SSHSideEffect()

2352 hook.append(self.mover.output_get_physical_devices())

2353

2354 ssh_cmd_mock = mock.Mock(side_effect=hook)

2355 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

2356 self.connection.port_conf = ['cge-2-0']

2357

2358 self.assertRaises(exception.BadConfigurationException,

2359 self.connection.get_managed_ports)

2360

2361 def test_get_managed_ports_query_devices_failed(self):

2362 hook = utils.SSHSideEffect()

2363 hook.append(self.mover.fake_output)

2364 ssh_cmd_mock = mock.Mock(side_effect=hook)

2365 self.connection.manager.connectors['SSH'].run_ssh = ssh_cmd_mock

2366 self.connection.port_conf = ['cge-2-0']

2367

2368 self.assertRaises(exception.EMCVnxXMLAPIError,

2369 self.connection.get_managed_ports)

Coverage for manila/tests/share/drivers/dell_emc/plugins/powermax/test_connection.py: 100%

1249 statements