Coverage for manila/share/manager.py: 86%

1# Copyright (c) 2014 NetApp Inc. 

2# All Rights Reserved. 

3# 

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 

7# 

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

9# 

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. 

15"""NAS share manager managers creating shares and access rights. 

16 

17**Related Flags** 

18 

19:share_driver: Used by :class:`ShareManager`. 

20""" 

21 

22import copy 

23import datetime 

24import functools 

25import hashlib 

26import json 

27from operator import xor 

28 

29from keystoneauth1 import loading as ks_loading 

30from oslo_config import cfg 

31from oslo_log import log 

32from oslo_serialization import jsonutils 

33from oslo_service import periodic_task 

34from oslo_utils import excutils 

35from oslo_utils import importutils 

36from oslo_utils import timeutils 

37 

38from manila.common import constants 

39from manila import context 

40from manila import coordination 

41from manila.data import rpcapi as data_rpcapi 

42from manila import exception 

43from manila.i18n import _ 

44from manila.keymgr import barbican as barbican_api 

45from manila import manager 

46from manila.message import api as message_api 

47from manila.message import message_field 

48from manila import quota 

49from manila.share import access 

50from manila.share import api 

51from manila.share import configuration 

52from manila.share import drivers_private_data 

53from manila.share import migration 

54from manila.share import rpcapi as share_rpcapi 

55from manila.share import share_types 

56from manila.share import snapshot_access 

57from manila.share import utils as share_utils 

58from manila.transfer import api as transfer_api 

59from manila import utils 

60 

61profiler = importutils.try_import('osprofiler.profiler') 

62 

63LOG = log.getLogger(__name__) 

64 

65share_manager_opts = [ 

66 cfg.StrOpt('share_driver', 

67 default='manila.share.drivers.generic.GenericShareDriver', 

68 help='Driver to use for share creation.'), 

69 cfg.ListOpt('hook_drivers', 

70 default=[], 

71 help='Driver(s) to perform some additional actions before and ' 

72 'after share driver actions and on a periodic basis. ' 

73 'Default is [].'), 

74 cfg.BoolOpt('delete_share_server_with_last_share', 

75 default=False, 

76 help='Whether share servers will ' 

77 'be deleted on deletion of the last share.'), 

78 cfg.BoolOpt('unmanage_remove_access_rules', 

79 default=False, 

80 help='If set to True, then manila will deny access and remove ' 

81 'all access rules on share unmanage.' 

82 'If set to False - nothing will be changed.'), 

83 cfg.BoolOpt('automatic_share_server_cleanup', 

84 default=True, 

85 help='If set to True, then Manila will delete all share ' 

86 'servers which were unused more than specified time .' 

87 'If set to False - automatic deletion of share servers ' 

88 'will be disabled.'), 

89 cfg.IntOpt('unused_share_server_cleanup_interval', 

90 default=10, 

91 help='Unallocated share servers reclamation time interval ' 

92 '(minutes). Minimum value is 10 minutes, maximum is 720 ' 

93 'minutes. The reclamation function is run every ' 

94 '10 minutes and delete share servers which were unused ' 

95 'more than unused_share_server_cleanup_interval option ' 

96 'defines. This value reflects the shortest time Manila ' 

97 'will wait for a share server to go unutilized before ' 

98 'deleting it.', 

99 min=10, 

100 max=720), 

101 cfg.IntOpt('replica_state_update_interval', 

102 default=300, 

103 help='This value, specified in seconds, determines how often ' 

104 'the share manager will poll for the health ' 

105 '(replica_state) of each replica instance.'), 

106 cfg.IntOpt('migration_driver_continue_update_interval', 

107 default=60, 

108 help='This value, specified in seconds, determines how often ' 

109 'the share manager will poll the driver to perform the ' 

110 'next step of migration in the storage backend, for a ' 

111 'migrating share.'), 

112 cfg.IntOpt('server_migration_driver_continue_update_interval', 

113 default=900, 

114 help='This value, specified in seconds, determines how often ' 

115 'the share manager will poll the driver to perform the ' 

116 'next step of migration in the storage backend, for a ' 

117 'migrating share server.'), 

118 cfg.BoolOpt('server_migration_extend_neutron_network', 

119 default=False, 

120 help='If set to True, neutron network are extended to ' 

121 'destination host during share server migration. This ' 

122 'option should only be enabled if using ' 

123 'NeutronNetworkPlugin or its derivatives and when ' 

124 'multiple bindings of Manila ports are supported by ' 

125 'Neutron ML2 plugin.'), 

126 cfg.IntOpt('share_usage_size_update_interval', 

127 default=300, 

128 help='This value, specified in seconds, determines how often ' 

129 'the share manager will poll the driver to update the ' 

130 'share usage size in the storage backend, for shares in ' 

131 'that backend.'), 

132 cfg.BoolOpt('enable_gathering_share_usage_size', 

133 default=False, 

134 help='If set to True, share usage size will be polled for in ' 

135 'the interval specified with ' 

136 '"share_usage_size_update_interval". Usage data can be ' 

137 'consumed by telemetry integration. If telemetry is not ' 

138 'configured, this option must be set to False. ' 

139 'If set to False - gathering share usage size will be' 

140 ' disabled.'), 

141 cfg.BoolOpt('share_service_inithost_offload', 

142 default=False, 

143 help='Offload pending share ensure during ' 

144 'share service startup'), 

145 cfg.IntOpt('check_for_expired_shares_in_recycle_bin_interval', 

146 default=3600, 

147 help='This value, specified in seconds, determines how often ' 

148 'the share manager will check for expired shares and ' 

149 'delete them from the Recycle bin.'), 

150 cfg.IntOpt('check_for_expired_transfers', 

151 default=300, 

152 help='This value, specified in seconds, determines how often ' 

153 'the share manager will check for expired transfers and ' 

154 'destroy them and roll back share state.'), 

155 cfg.IntOpt('driver_backup_continue_update_interval', 

156 default=60, 

157 help='This value, specified in seconds, determines how often ' 

158 'the share manager will poll to perform the next steps ' 

159 'of backup such as fetch the progress of backup.'), 

160 cfg.IntOpt('driver_restore_continue_update_interval', 

161 default=60, 

162 help='This value, specified in seconds, determines how often ' 

163 'the share manager will poll to perform the next steps ' 

164 'of restore such as fetch the progress of restore.'), 

165 cfg.IntOpt('periodic_deferred_delete_interval', 

166 default=300, 

167 help='This value, specified in seconds, determines how often ' 

168 'the share manager will try to delete the share and share ' 

169 'snapshots in backend driver.'), 

170] 

171 

172 

173ks_opts = [ 

174 cfg.StrOpt('auth_url', 

175 help='Keystone authentication URL.'), 

176] 

177 

178CONF = cfg.CONF 

179CONF.register_opts(share_manager_opts) 

180CONF.import_opt('periodic_hooks_interval', 'manila.share.hook') 

181CONF.import_opt('periodic_interval', 'manila.service') 

182 

183KEYSTONE_AUTHTOKEN_GROUP = 'keystone_authtoken' 

184CONF.register_opts(ks_opts, KEYSTONE_AUTHTOKEN_GROUP) 

185ks_loading.register_auth_conf_options(CONF, KEYSTONE_AUTHTOKEN_GROUP) 

186keystone_url = getattr(CONF.keystone_authtoken, 'auth_url') 

187 

188# Drivers that need to change module paths or class names can add their 

189# old/new path here to maintain backward compatibility. 

190MAPPING = { 

191 'manila.share.drivers.netapp.cluster_mode.NetAppClusteredShareDriver': 

192 'manila.share.drivers.netapp.common.NetAppDriver', 

193 'manila.share.drivers.hp.hp_3par_driver.HP3ParShareDriver': 

194 'manila.share.drivers.hpe.hpe_3par_driver.HPE3ParShareDriver', 

195 'manila.share.drivers.hitachi.hds_hnas.HDSHNASDriver': 

196 'manila.share.drivers.hitachi.hnas.driver.HitachiHNASDriver', 

197 'manila.share.drivers.glusterfs_native.GlusterfsNativeShareDriver': 

198 'manila.share.drivers.glusterfs.glusterfs_native.' 

199 'GlusterfsNativeShareDriver', 

200 'manila.share.drivers.emc.driver.EMCShareDriver': 

201 'manila.share.drivers.dell_emc.driver.EMCShareDriver', 

202 'manila.share.drivers.cephfs.cephfs_native.CephFSNativeDriver': 

203 'manila.share.drivers.cephfs.driver.CephFSDriver', 

204} 

205 

206QUOTAS = quota.QUOTAS 

207 

208 

209def locked_share_replica_operation(operation): 

210 """Lock decorator for share replica operations. 

211 

212 Takes a named lock prior to executing the operation. The lock is named with 

213 the id of the share to which the replica belongs. 

214 

215 Intended use: 

216 If a replica operation uses this decorator, it will block actions on 

217 all share replicas of the share until the named lock is free. This is 

218 used to protect concurrent operations on replicas of the same share e.g. 

219 promote ReplicaA while deleting ReplicaB, both belonging to the same share. 

220 """ 

221 

222 def wrapped(*args, **kwargs): 

223 share_id = kwargs.get('share_id') 

224 

225 @coordination.synchronized( 

226 'locked-share-replica-operation-for-share-%s' % share_id) 

227 def locked_replica_operation(*_args, **_kwargs): 

228 return operation(*_args, **_kwargs) 

229 return locked_replica_operation(*args, **kwargs) 

230 

231 return wrapped 

232 

233 

234def locked_share_network_operation(operation): 

235 """Lock decorator for share network operations. 

236 

237 Takes a named lock prior to executing the operation. The lock is named with 

238 the id of the share network. 

239 """ 

240 

241 def wrapped(*args, **kwargs): 

242 share_network_id = kwargs.get('share_network_id') 

243 

244 @coordination.synchronized( 

245 'locked-share-network-operation-%s' % share_network_id) 

246 def locked_network_operation(*_args, **_kwargs): 

247 return operation(*_args, **_kwargs) 

248 return locked_network_operation(*args, **kwargs) 

249 

250 return wrapped 

251 

252 

253def add_hooks(f): 

254 """Hook decorator to perform action before and after a share method call 

255 

256 The hook decorator can perform actions before some share driver methods 

257 calls and after a call with results of driver call and preceding hook call. 

258 """ 

259 @functools.wraps(f) 

260 def wrapped(self, *args, **kwargs): 

261 if not self.hooks: 

262 return f(self, *args, **kwargs) 

263 

264 pre_hook_results = [] 

265 for hook in self.hooks: 

266 pre_hook_results.append( 

267 hook.execute_pre_hook( 

268 func_name=f.__name__, 

269 *args, **kwargs)) 

270 

271 wrapped_func_results = f(self, *args, **kwargs) 

272 

273 for i, hook in enumerate(self.hooks): 

274 hook.execute_post_hook( 

275 func_name=f.__name__, 

276 driver_action_results=wrapped_func_results, 

277 pre_hook_data=pre_hook_results[i], 

278 *args, **kwargs) 

279 

280 return wrapped_func_results 

281 

282 return wrapped 

283 

284 

285class ShareManager(manager.SchedulerDependentManager): 

286 """Manages NAS storages.""" 

287 

288 RPC_API_VERSION = '1.30' 

289 

290 def __init__(self, share_driver=None, service_name=None, *args, **kwargs): 

291 """Load the driver from args, or from flags.""" 

292 self.configuration = configuration.Configuration( 

293 share_manager_opts, 

294 config_group=service_name) 

295 super(ShareManager, self).__init__(service_name='share', 

296 *args, **kwargs) 

297 

298 if not share_driver: 298 ↛ 300line 298 didn't jump to line 300 because the condition on line 298 was always true

299 share_driver = self.configuration.share_driver 

300 if share_driver in MAPPING: 300 ↛ 301line 300 didn't jump to line 301 because the condition on line 300 was never true

301 msg_args = {'old': share_driver, 'new': MAPPING[share_driver]} 

302 LOG.warning("Driver path %(old)s is deprecated, update your " 

303 "configuration to the new path %(new)s", 

304 msg_args) 

305 share_driver = MAPPING[share_driver] 

306 

307 ctxt = context.get_admin_context() 

308 private_storage = drivers_private_data.DriverPrivateData( 

309 context=ctxt, backend_host=self.host, 

310 config_group=self.configuration.config_group 

311 ) 

312 self.driver = importutils.import_object( 

313 share_driver, private_storage=private_storage, 

314 configuration=self.configuration, 

315 ) 

316 

317 backend_availability_zone = self.driver.configuration.safe_get( 

318 'backend_availability_zone') 

319 self.availability_zone = ( 

320 backend_availability_zone or CONF.storage_availability_zone 

321 ) 

322 

323 self.access_helper = access.ShareInstanceAccess(self.db, self.driver) 

324 self.snapshot_access_helper = ( 

325 snapshot_access.ShareSnapshotInstanceAccess(self.db, self.driver)) 

326 self.migration_wait_access_rules_timeout = ( 

327 CONF.migration_wait_access_rules_timeout) 

328 

329 self.message_api = message_api.API() 

330 self.share_api = api.API() 

331 self.transfer_api = transfer_api.API() 

332 if CONF.profiler.enabled and profiler is not None: 332 ↛ 333line 332 didn't jump to line 333 because the condition on line 332 was never true

333 self.driver = profiler.trace_cls("driver")(self.driver) 

334 self.hooks = [] 

335 self._init_hook_drivers() 

336 self.service_id = None 

337 

338 def _init_hook_drivers(self): 

339 # Try to initialize hook driver(s). 

340 hook_drivers = self.configuration.safe_get("hook_drivers") 

341 for hook_driver in hook_drivers: 

342 self.hooks.append( 

343 importutils.import_object( 

344 hook_driver, 

345 configuration=self.configuration, 

346 host=self.host, 

347 ) 

348 ) 

349 

350 def _ensure_share_instance_has_pool(self, ctxt, share_instance): 

351 pool = share_utils.extract_host(share_instance['host'], 'pool') 

352 if pool is None: 

353 # No pool name encoded in host, so this is a legacy 

354 # share created before pool is introduced, ask 

355 # driver to provide pool info if it has such 

356 # knowledge and update the DB. 

357 try: 

358 pool = self.driver.get_pool(share_instance) 

359 except Exception: 

360 LOG.exception("Failed to fetch pool name for share: " 

361 "%(share)s.", 

362 {'share': share_instance['id']}) 

363 return 

364 

365 if pool: 

366 new_host = share_utils.append_host( 

367 share_instance['host'], pool) 

368 self.db.share_instance_update( 

369 ctxt, share_instance['id'], {'host': new_host}) 

370 

371 return pool 

372 

373 @add_hooks 

374 def init_host(self, service_id=None): 

375 """Initialization for a standalone service.""" 

376 

377 self.service_id = service_id 

378 ctxt = context.get_admin_context() 

379 driver_host_pair = "{}@{}".format( 

380 self.driver.__class__.__name__, 

381 self.host) 

382 

383 # we want to retry to setup the driver. In case of a multi-backend 

384 # scenario, working backends are usable and the non-working ones (where 

385 # do_setup() or check_for_setup_error() fail) retry. 

386 @utils.retry(interval=2, backoff_rate=2, 

387 infinite=True, backoff_sleep_max=600) 

388 def _driver_setup(): 

389 self.driver.initialized = False 

390 LOG.debug("Start initialization of driver: '%s'", driver_host_pair) 

391 try: 

392 self.driver.do_setup(ctxt) 

393 self.driver.check_for_setup_error() 

394 except Exception: 

395 LOG.exception("Error encountered during initialization of " 

396 "driver %s", driver_host_pair) 

397 raise 

398 else: 

399 self.driver.initialized = True 

400 

401 _driver_setup() 

402 if (self.driver.driver_handles_share_servers and 402 ↛ 407line 402 didn't jump to line 407 because the condition on line 402 was always true

403 hasattr(self.driver, 'service_instance_manager')): 

404 (self.driver.service_instance_manager.network_helper. 

405 setup_connectivity_with_service_instances()) 

406 

407 self.ensure_driver_resources(ctxt) 

408 

409 self.publish_service_capabilities(ctxt) 

410 LOG.info("Finished initialization of driver: '%(driver)s" 

411 "@%(host)s'", 

412 {"driver": self.driver.__class__.__name__, 

413 "host": self.host}) 

414 

415 def is_service_ready(self): 

416 """Return if Manager is ready to accept requests. 

417 

418 This is to inform Service class that in case of manila driver 

419 initialization failure the manager is actually down and not ready to 

420 accept any requests. 

421 

422 """ 

423 return self.driver.initialized 

424 

425 def ensure_driver_resources(self, ctxt, skip_backend_info_check=False): 

426 update_instances_status = CONF.update_shares_status_on_ensure 

427 old_backend_info = self.db.backend_info_get(ctxt, self.host) 

428 old_backend_info_hash = (old_backend_info.get('info_hash') 

429 if old_backend_info is not None else None) 

430 new_backend_info = None 

431 new_backend_info_hash = None 

432 backend_info_implemented = True 

433 update_share_instances = [] 

434 if not skip_backend_info_check: 434 ↛ 462line 434 didn't jump to line 462 because the condition on line 434 was always true

435 try: 

436 new_backend_info = self.driver.get_backend_info(ctxt) 

437 except Exception as e: 

438 if not isinstance(e, NotImplementedError): 

439 LOG.exception( 

440 "The backend %(host)s could not get backend info.", 

441 {'host': self.host}) 

442 raise 

443 else: 

444 backend_info_implemented = False 

445 LOG.debug( 

446 ("The backend %(host)s does not support get backend" 

447 " info method."), 

448 {'host': self.host}) 

449 

450 if new_backend_info: 

451 new_backend_info_hash = hashlib.sha1( 

452 str(sorted(new_backend_info.items())).encode( 

453 'utf-8')).hexdigest() 

454 if ((old_backend_info_hash == new_backend_info_hash and 

455 backend_info_implemented) and not skip_backend_info_check): 

456 LOG.debug( 

457 ("Ensure shares is being skipped because the %(host)s's " 

458 "old backend info is the same as its new backend info."), 

459 {'host': self.host}) 

460 return 

461 

462 share_instances = self.db.share_instance_get_all_by_host( 

463 ctxt, self.host) 

464 LOG.debug("Re-exporting %s shares", len(share_instances)) 

465 

466 for share_instance in share_instances: 

467 share_ref = self.db.share_get(ctxt, share_instance['share_id']) 

468 

469 if share_ref.is_busy: 

470 LOG.info( 

471 "Share instance %(id)s: skipping export, " 

472 "because it is busy with an active task: %(task)s.", 

473 {'id': share_instance['id'], 

474 'task': share_ref['task_state']}, 

475 ) 

476 continue 

477 

478 # If the share's status is 'ensuring', we must allow re-doing the 

479 # ensuring operation otherwise it will be stuck 

480 if (share_instance['status'] not in 

481 [constants.STATUS_AVAILABLE, constants.STATUS_ENSURING]): 

482 LOG.info( 

483 "Share instance %(id)s: skipping export, " 

484 "because it has '%(status)s' status.", 

485 {'id': share_instance['id'], 

486 'status': share_instance['status']}, 

487 ) 

488 continue 

489 

490 self._ensure_share_instance_has_pool(ctxt, share_instance) 

491 share_instance = self.db.share_instance_get( 

492 ctxt, share_instance['id'], with_share_data=True) 

493 share_instance_dict = self._get_share_instance_dict( 

494 ctxt, share_instance) 

495 update_share_instances.append(share_instance_dict) 

496 

497 do_service_status_update = False 

498 if update_share_instances: 

499 # No reason to update the shares status if nothing will be done. 

500 do_service_status_update = True 

501 service = self.db.service_get_by_args( 

502 ctxt, self.host, 'manila-share') 

503 self.db.service_update(ctxt, service['id'], {'ensuring': True}) 

504 if update_instances_status: 504 ↛ 510line 504 didn't jump to line 510 because the condition on line 504 was always true

505 for instance in update_share_instances: 

506 self.db.share_instance_update( 

507 ctxt, instance['id'], 

508 {'status': constants.STATUS_ENSURING} 

509 ) 

510 try: 

511 update_share_instances = self.driver.ensure_shares( 

512 ctxt, update_share_instances) or {} 

513 except Exception as e: 

514 if not isinstance(e, NotImplementedError): 

515 LOG.exception("Caught exception trying ensure " 

516 "share instances.") 

517 else: 

518 for share_instance in update_share_instances: 

519 if CONF.share_service_inithost_offload: 519 ↛ 520line 519 didn't jump to line 520 because the condition on line 519 was never true

520 self._add_to_threadpool(self._ensure_share, 

521 ctxt, share_instance) 

522 else: 

523 self._ensure_share(ctxt, share_instance) 

524 # At this point, we assume that the ensuring operation is 

525 # complete or everything is okay, even though it might be 

526 # running on different threads. 

527 LOG.debug( 

528 "Shares' export locations were ensured individually, " 

529 "so triggering the ensure shares operation is " 

530 "complete.") 

531 self.db.service_update( 

532 ctxt, service['id'], {'ensuring': False}) 

533 

534 if new_backend_info: 

535 self.db.backend_info_update( 

536 ctxt, self.host, new_backend_info_hash) 

537 

538 shares_with_metadata_already_updated = set() 

539 for share_instance in share_instances: 

540 if share_instance['id'] not in update_share_instances: 

541 continue 

542 share_instance_update_dict = ( 

543 update_share_instances[share_instance['id']] 

544 ) 

545 backend_provided_status = share_instance_update_dict.get('status') 

546 if backend_provided_status: 

547 self.db.share_instance_update( 

548 ctxt, share_instance['id'], 

549 {'status': backend_provided_status, 

550 'host': share_instance['host']} 

551 ) 

552 metadata_updates = share_instance_update_dict.get('metadata') 

553 if metadata_updates: 

554 share_id = share_instance['share_id'] 

555 # NOTE(carloss): Multiple instances might exist, and in such 

556 # cases, a single share metadata update would be enough. 

557 if share_id not in shares_with_metadata_already_updated: 557 ↛ 562line 557 didn't jump to line 562 because the condition on line 557 was always true

558 self.db.share_metadata_update( 

559 ctxt, share_id, metadata_updates, False) 

560 shares_with_metadata_already_updated.add(share_id) 

561 

562 update_export_locations = ( 

563 share_instance_update_dict.get('export_locations') 

564 ) 

565 if update_export_locations: 

566 self.db.export_locations_update( 

567 ctxt, share_instance['id'], update_export_locations) 

568 

569 share_server = self._get_share_server(ctxt, share_instance) 

570 driver_has_to_reapply_access_rules = ( 

571 share_instance_update_dict.get('reapply_access_rules') is True 

572 ) 

573 share_instance_has_pending_rules = ( 

574 share_instance['access_rules_status'] != 

575 constants.STATUS_ACTIVE 

576 ) 

577 if (driver_has_to_reapply_access_rules or 

578 share_instance_has_pending_rules): 

579 try: 

580 # Cast any existing 'applying' rules to 'new' 

581 self.access_helper.reset_rules_to_queueing_states( 

582 ctxt, share_instance['id'], 

583 reset_active=driver_has_to_reapply_access_rules) 

584 self.access_helper.update_access_rules( 

585 ctxt, share_instance['id'], share_server=share_server) 

586 except Exception: 

587 LOG.exception( 

588 ("Unexpected error occurred while updating access " 

589 "rules for share instance %(s_id)s."), 

590 {'s_id': share_instance['id']}, 

591 ) 

592 

593 snapshot_instances = ( 

594 self.db.share_snapshot_instance_get_all_with_filters( 

595 ctxt, {'share_instance_ids': share_instance['id']}, 

596 with_share_data=True)) 

597 

598 for snap_instance in snapshot_instances: 598 ↛ 600line 598 didn't jump to line 600 because the loop on line 598 never started

599 

600 rules = ( 

601 self.db. 

602 share_snapshot_access_get_all_for_snapshot_instance( 

603 ctxt, snap_instance['id'])) 

604 

605 # NOTE(ganso): We don't invoke update_access for snapshots if 

606 # we don't have invalid rules or pending updates 

607 if any(r['state'] in (constants.ACCESS_STATE_DENYING, 

608 constants.ACCESS_STATE_QUEUED_TO_DENY, 

609 constants.ACCESS_STATE_APPLYING, 

610 constants.ACCESS_STATE_QUEUED_TO_APPLY) 

611 for r in rules): 

612 try: 

613 self.snapshot_access_helper.update_access_rules( 

614 ctxt, snap_instance['id'], share_server) 

615 except Exception: 

616 LOG.exception( 

617 "Unexpected error occurred while updating " 

618 "access rules for snapshot instance %s.", 

619 snap_instance['id']) 

620 if not backend_provided_status and update_instances_status: 

621 self.db.share_instance_update( 

622 ctxt, share_instance['id'], 

623 {'status': constants.STATUS_AVAILABLE} 

624 ) 

625 if do_service_status_update: 

626 self.db.service_update(ctxt, service['id'], {'ensuring': False}) 

627 

628 def _ensure_share(self, ctxt, share_instance): 

629 export_locations = None 

630 try: 

631 export_locations = self.driver.ensure_share( 

632 ctxt, share_instance, 

633 share_server=share_instance['share_server']) 

634 except Exception: 

635 LOG.exception("Caught exception trying ensure " 

636 "share '%(s_id)s'.", 

637 {'s_id': share_instance['id']}) 

638 if export_locations: 

639 self.db.export_locations_update( 

640 ctxt, share_instance['id'], export_locations) 

641 

642 # NOTE(carloss): we can't determine if the share is actually alright, 

643 # but we expect that after the export location is updated in the 

644 # database, everything is okay. 

645 self.db.share_instance_update( 

646 ctxt, share_instance['id'], 

647 {'status': constants.STATUS_AVAILABLE} 

648 ) 

649 

650 def _check_share_server_backend_limits( 

651 self, context, available_share_servers, share_instance=None): 

652 max_shares_limit = self.driver.max_shares_per_share_server 

653 max_server_size = self.driver.max_share_server_size 

654 

655 if max_server_size == max_shares_limit == -1: 

656 return available_share_servers 

657 

658 for ss in available_share_servers[:]: 

659 share_instances = self.db.share_instance_get_all_by_share_server( 

660 context, ss['id'], with_share_data=True) 

661 if not share_instances: 661 ↛ 662line 661 didn't jump to line 662 because the condition on line 661 was never true

662 continue 

663 share_instance_ids = [si['id'] for si in share_instances] 

664 share_snapshot_instances = ( 

665 self.db.share_snapshot_instance_get_all_with_filters( 

666 context, {"share_instance_ids": share_instance_ids}, 

667 with_share_data=True)) 

668 

669 server_instances_size_sum = 0 

670 num_instances = 0 

671 

672 server_instances_size_sum += sum( 

673 instance['size'] for instance in share_instances) 

674 server_instances_size_sum += sum( 

675 instance['size'] for instance in share_snapshot_instances) 

676 num_instances += len(share_instances) 

677 

678 # NOTE(carloss): If a share instance was not provided, means that 

679 # a share group is being requested and there aren't shares to 

680 # be added to to the sum yet. 

681 if share_instance: 

682 server_instances_size_sum += share_instance['size'] 

683 num_instances += 1 

684 

685 achieved_gigabytes_limit = ( 

686 max_server_size != -1 and ( 

687 server_instances_size_sum > max_server_size)) 

688 

689 achieved_instances_limit = num_instances > max_shares_limit > -1 

690 

691 providing_server_for_share_migration = ( 

692 share_instance and share_instance['status'] == 

693 constants.STATUS_MIGRATING_TO) 

694 

695 src_server_id_equals_current_iteration = False 

696 

697 if providing_server_for_share_migration: 

698 share = self.db.share_get(context, share_instance['share_id']) 

699 src_instance_id, dest_instance_id = ( 

700 self.share_api.get_migrating_instances(share)) 

701 src_instance = self.db.share_instance_get( 

702 context, src_instance_id) 

703 src_server_id_equals_current_iteration = ( 

704 src_instance['share_server_id'] == ss['id']) 

705 

706 if (not src_server_id_equals_current_iteration and ( 

707 achieved_gigabytes_limit or achieved_instances_limit)): 

708 available_share_servers.remove(ss) 

709 

710 return available_share_servers 

711 

712 def _provide_share_server_for_share(self, context, share_network_id, 

713 share_instance, snapshot=None, 

714 share_group=None, 

715 create_on_backend=True): 

716 """Gets or creates share_server and updates share with its id. 

717 

718 Active share_server can be deleted if there are no dependent shares 

719 on it. 

720 So we need avoid possibility to delete share_server in time gap 

721 between reaching active state for share_server and setting up 

722 share_server_id for share. It is possible, for example, with first 

723 share creation, which starts share_server creation. 

724 For this purpose used shared lock between this method and the one 

725 with deletion of share_server. 

726 

727 :param context: Current context 

728 :param share_network_id: Share network where existing share server 

729 should be found or created. If 

730 share_network_id is None method use 

731 share_network_id from provided snapshot. 

732 :param share_instance: Share Instance model 

733 :param snapshot: Optional -- Snapshot model 

734 :param create_on_backend: Boolean. If True, driver will be asked to 

735 create the share server if no share server 

736 is available. 

737 

738 :returns: dict, dict -- first value is share_server, that 

739 has been chosen for share schedule. Second value is 

740 share updated with share_server_id. 

741 """ 

742 if not (share_network_id or snapshot): 

743 msg = _("'share_network_id' parameter or 'snapshot'" 

744 " should be provided. ") 

745 raise ValueError(msg) 

746 

747 def error(msg, *args): 

748 LOG.error(msg, *args) 

749 self.db.share_instance_update(context, share_instance['id'], 

750 {'status': constants.STATUS_ERROR}) 

751 parent_share_server = None 

752 parent_share_same_dest = False 

753 if snapshot: 

754 parent_share_server_id = ( 

755 snapshot['share']['instance']['share_server_id']) 

756 try: 

757 parent_share_server = self.db.share_server_get( 

758 context, parent_share_server_id) 

759 except exception.ShareServerNotFound: 

760 with excutils.save_and_reraise_exception(): 

761 error("Parent share server %s does not exist.", 

762 parent_share_server_id) 

763 

764 if parent_share_server['status'] != constants.STATUS_ACTIVE: 

765 error_params = { 

766 'id': parent_share_server_id, 

767 'status': parent_share_server['status'], 

768 } 

769 msg = _("Parent share server %(id)s has invalid status " 

770 "'%(status)s'.") 

771 error(msg, error_params) 

772 raise exception.InvalidShareServer(reason=msg % error_params) 

773 parent_share_same_dest = (snapshot['share']['instance']['host'] 

774 == share_instance['host']) 

775 share_network_subnets = None 

776 if share_network_id: 

777 share_network_subnets = ( 

778 self.db.share_network_subnets_get_all_by_availability_zone_id( 

779 context, share_network_id, 

780 availability_zone_id=share_instance.get( 

781 'availability_zone_id'))) 

782 if not share_network_subnets: 

783 raise exception.ShareNetworkSubnetNotFound( 

784 share_network_subnet_id=None) 

785 elif parent_share_server: 785 ↛ 793line 785 didn't jump to line 793 because the condition on line 785 was always true

786 share_network_subnets = ( 

787 parent_share_server['share_network_subnets']) 

788 

789 # NOTE(felipe_rodrigues): it can retrieve the available share 

790 # servers using one single subnet_id from the availability zone 

791 # subnets, because if the share server has one, it will have 

792 # all subnets on that availability zone. 

793 share_network_subnet_id = share_network_subnets[0]['id'] 

794 

795 def get_available_share_servers(): 

796 if parent_share_server and parent_share_same_dest: 

797 return [parent_share_server] 

798 else: 

799 return ( 

800 self.db 

801 .share_server_get_all_by_host_and_share_subnet_valid( 

802 context, self.host, share_network_subnet_id) 

803 ) 

804 

805 @utils.synchronized("share_manager_%s" % share_network_subnet_id, 

806 external=True) 

807 def _wrapped_provide_share_server_for_share(): 

808 try: 

809 available_share_servers = get_available_share_servers() 

810 except exception.ShareServerNotFound: 

811 available_share_servers = None 

812 

813 # creating from snapshot in the same host must reuse the server, 

814 # so it ignores the server limits. 

815 if available_share_servers and not parent_share_same_dest: 

816 available_share_servers = ( 

817 self._check_share_server_backend_limits( 

818 context, available_share_servers, 

819 share_instance=share_instance)) 

820 

821 encryption_key_ref = share_instance.get('encryption_key_ref') 

822 

823 compatible_share_server = None 

824 if available_share_servers: 

825 try: 

826 compatible_share_server = ( 

827 self.driver.choose_share_server_compatible_with_share( 

828 context, available_share_servers, share_instance, 

829 snapshot=snapshot.instance if snapshot else None, 

830 share_group=share_group, 

831 encryption_key_ref=encryption_key_ref, 

832 ) 

833 ) 

834 except Exception as e: 

835 with excutils.save_and_reraise_exception(): 

836 error("Cannot choose compatible share server: %s", 

837 e) 

838 

839 share_server_should_be_encrypted = ( 

840 (encryption_key_ref and self.driver.encryption_support) and 

841 ("share_server" in self.driver.encryption_support)) 

842 

843 app_cred = None 

844 if not compatible_share_server: 

845 if share_server_should_be_encrypted: 

846 # Create secret_ref ACL for Barbican User 

847 try: 

848 barbican_api.create_secret_access(context, 

849 encryption_key_ref) 

850 LOG.debug('Created Barbican ACL for encryption key ' 

851 'reference %s.', encryption_key_ref) 

852 except Exception as e: 

853 self._delete_encryption_keys_quota(context) 

854 with excutils.save_and_reraise_exception(): 

855 error("Cannot create ACL for Barbican user %s", e) 

856 

857 # Create application credentials for barbican user 

858 try: 

859 app_cred = ( 

860 barbican_api.create_application_credentials( 

861 context, encryption_key_ref).to_dict()) 

862 LOG.debug("Created app cred id %s", app_cred['id']) 

863 except Exception as e: 

864 self._delete_encryption_keys_quota(context) 

865 barbican_api.delete_secret_access(context, 

866 encryption_key_ref) 

867 with excutils.save_and_reraise_exception(): 

868 error("Cannot create application credential: " 

869 "%s", e) 

870 

871 compatible_share_server = self.db.share_server_create( 

872 context, 

873 { 

874 'host': self.host, 

875 'share_network_subnets': share_network_subnets, 

876 'status': constants.STATUS_CREATING, 

877 'security_service_update_support': ( 

878 self.driver.security_service_update_support), 

879 'network_allocation_update_support': ( 

880 self.driver.network_allocation_update_support), 

881 'share_replicas_migration_support': ( 

882 self.driver.share_replicas_migration_support), 

883 'encryption_key_ref': ( 

884 encryption_key_ref if