Coverage for manila/share/drivers/zfsonlinux/driver.py: 99%

1# Copyright 2016 Mirantis 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 

16""" 

17Module with ZFSonLinux share driver that utilizes ZFS filesystem resources 

18and exports them as shares. 

19""" 

20 

21import math 

22import os 

23import time 

24 

25from oslo_config import cfg 

26from oslo_log import log 

27from oslo_utils import importutils 

28from oslo_utils import strutils 

29from oslo_utils import timeutils 

30 

31from manila.common import constants 

32from manila import exception 

33from manila.i18n import _ 

34from manila.share import configuration 

35from manila.share import driver 

36from manila.share.drivers.zfsonlinux import utils as zfs_utils 

37from manila.share.manager import share_manager_opts # noqa 

38from manila.share import share_types 

39from manila.share import utils as share_utils 

40from manila import utils 

41 

42 

43zfsonlinux_opts = [ 

44 cfg.HostAddressOpt( 

45 "zfs_share_export_ip", 

46 required=True, 

47 help="IP to be added to user-facing export location. Required."), 

48 cfg.HostAddressOpt( 

49 "zfs_service_ip", 

50 required=True, 

51 help="IP to be added to admin-facing export location. Required."), 

52 cfg.ListOpt( 

53 "zfs_zpool_list", 

54 required=True, 

55 help="Specify list of zpools that are allowed to be used by backend. " 

56 "Can contain nested datasets. Examples: " 

57 "Without nested dataset: 'zpool_name'. " 

58 "With nested dataset: 'zpool_name/nested_dataset_name'. " 

59 "Required."), 

60 cfg.ListOpt( 

61 "zfs_dataset_creation_options", 

62 help="Define here list of options that should be applied " 

63 "for each dataset creation if needed. Example: " 

64 "compression=gzip,dedup=off. " 

65 "Note that, for secondary replicas option 'readonly' will be set " 

66 "to 'on' and for active replicas to 'off' in any way. " 

67 "Also, 'quota' will be equal to share size. Optional."), 

68 cfg.StrOpt( 

69 "zfs_dataset_name_prefix", 

70 default='manila_share_', 

71 help="Prefix to be used in each dataset name. Optional."), 

72 cfg.StrOpt( 

73 "zfs_dataset_snapshot_name_prefix", 

74 default='manila_share_snapshot_', 

75 help="Prefix to be used in each dataset snapshot name. Optional."), 

76 cfg.BoolOpt( 

77 "zfs_use_ssh", 

78 default=False, 

79 help="Remote ZFS storage hostname that should be used for SSH'ing. " 

80 "Optional."), 

81 cfg.StrOpt( 

82 "zfs_ssh_username", 

83 help="SSH user that will be used in 2 cases: " 

84 "1) By manila-share service in case it is located on different " 

85 "host than its ZFS storage. " 

86 "2) By manila-share services with other ZFS backends that " 

87 "perform replication. " 

88 "It is expected that SSH'ing will be key-based, passwordless. " 

89 "This user should be passwordless sudoer. Optional."), 

90 cfg.StrOpt( 

91 "zfs_ssh_user_password", 

92 secret=True, 

93 help="Password for user that is used for SSH'ing ZFS storage host. " 

94 "Not used for replication operations. They require " 

95 "passwordless SSH access. Optional."), 

96 cfg.StrOpt( 

97 "zfs_ssh_private_key_path", 

98 help="Path to SSH private key that should be used for SSH'ing ZFS " 

99 "storage host. Not used for replication operations. Optional."), 

100 cfg.ListOpt( 

101 "zfs_share_helpers", 

102 default=[ 

103 "NFS=manila.share.drivers.zfsonlinux.utils.NFSviaZFSHelper", 

104 ], 

105 help="Specify list of share export helpers for ZFS storage. " 

106 "It should look like following: " 

107 "'FOO_protocol=foo.FooClass,BAR_protocol=bar.BarClass'. " 

108 "Required."), 

109 cfg.StrOpt( 

110 "zfs_replica_snapshot_prefix", 

111 default="tmp_snapshot_for_replication_", 

112 help="Set snapshot prefix for usage in ZFS replication. Required."), 

113 cfg.StrOpt( 

114 "zfs_migration_snapshot_prefix", 

115 default="tmp_snapshot_for_share_migration_", 

116 help="Set snapshot prefix for usage in ZFS migration. Required."), 

117] 

118 

119CONF = cfg.CONF 

120CONF.register_opts(zfsonlinux_opts) 

121LOG = log.getLogger(__name__) 

122 

123 

124def ensure_share_server_not_provided(f): 

125 

126 def wrap(self, context, *args, **kwargs): 

127 server = kwargs.get( 

128 "share_server", kwargs.get("destination_share_server")) 

129 if server: 

130 raise exception.InvalidInput( 

131 reason=_("Share server handling is not available. " 

132 "But 'share_server' was provided. '%s'. " 

133 "Share network should not be used.") % server.get( 

134 "id", server)) 

135 return f(self, context, *args, **kwargs) 

136 

137 return wrap 

138 

139 

140def get_backend_configuration(backend_name): 

141 config_stanzas = CONF.list_all_sections() 

142 if backend_name not in config_stanzas: 

143 msg = _("Could not find backend stanza %(backend_name)s in " 

144 "configuration which is required for share replication and " 

145 "migration. Available stanzas are %(stanzas)s") 

146 params = { 

147 "stanzas": config_stanzas, 

148 "backend_name": backend_name, 

149 } 

150 raise exception.BadConfigurationException(reason=msg % params) 

151 

152 config = configuration.Configuration( 

153 driver.share_opts, config_group=backend_name) 

154 config.append_config_values(zfsonlinux_opts) 

155 config.append_config_values(share_manager_opts) 

156 config.append_config_values(driver.ssh_opts) 

157 

158 return config 

159 

160 

161class ZFSonLinuxShareDriver(zfs_utils.ExecuteMixin, driver.ShareDriver): 

162 

163 def __init__(self, *args, **kwargs): 

164 super(ZFSonLinuxShareDriver, self).__init__( 

165 [False], *args, config_opts=[zfsonlinux_opts], **kwargs) 

166 self.replica_snapshot_prefix = ( 

167 self.configuration.zfs_replica_snapshot_prefix) 

168 self.migration_snapshot_prefix = ( 

169 self.configuration.zfs_migration_snapshot_prefix) 

170 self.backend_name = self.configuration.safe_get( 

171 'share_backend_name') or 'ZFSonLinux' 

172 self.zpool_list = self._get_zpool_list() 

173 self.dataset_creation_options = ( 

174 self.configuration.zfs_dataset_creation_options) 

175 self.share_export_ip = self.configuration.zfs_share_export_ip 

176 self.service_ip = self.configuration.zfs_service_ip 

177 self.private_storage = kwargs.get('private_storage') 

178 self._helpers = {} 

179 

180 # Set config based capabilities 

181 self._init_common_capabilities() 

182 

183 self._shell_executors = {} 

184 

185 def _get_shell_executor_by_host(self, host): 

186 backend_name = share_utils.extract_host(host, level='backend_name') 

187 if backend_name in CONF.enabled_share_backends: 

188 # Return executor of this host 

189 return self.execute 

190 elif backend_name not in self._shell_executors: 

191 config = get_backend_configuration(backend_name) 

192 self._shell_executors[backend_name] = ( 

193 zfs_utils.get_remote_shell_executor( 

194 ip=config.zfs_service_ip, 

195 port=22, 

196 conn_timeout=config.ssh_conn_timeout, 

197 login=config.zfs_ssh_username, 

198 password=config.zfs_ssh_user_password, 

199 privatekey=config.zfs_ssh_private_key_path, 

200 max_size=10, 

201 ) 

202 ) 

203 # Return executor of remote host 

204 return self._shell_executors[backend_name] 

205 

206 def _init_common_capabilities(self): 

207 self.common_capabilities = {} 

208 if 'dedup=on' in self.dataset_creation_options: 

209 self.common_capabilities['dedupe'] = [True] 

210 elif 'dedup=off' in self.dataset_creation_options: 

211 self.common_capabilities['dedupe'] = [False] 

212 else: 

213 self.common_capabilities['dedupe'] = [True, False] 

214 

215 if 'compression=off' in self.dataset_creation_options: 

216 self.common_capabilities['compression'] = [False] 

217 elif any('compression=' in option 

218 for option in self.dataset_creation_options): 

219 self.common_capabilities['compression'] = [True] 

220 else: 

221 self.common_capabilities['compression'] = [True, False] 

222 

223 # NOTE(vponomaryov): Driver uses 'quota' approach for 

224 # ZFS dataset. So, we can consider it as 

225 # 'always thin provisioned' because this driver never reserves 

226 # space for dataset. 

227 self.common_capabilities['thin_provisioning'] = [True] 

228 self.common_capabilities['max_over_subscription_ratio'] = ( 

229 self.configuration.max_over_subscription_ratio) 

230 self.common_capabilities['qos'] = [False] 

231 

232 def _get_zpool_list(self): 

233 zpools = [] 

234 for zpool in self.configuration.zfs_zpool_list: 

235 zpool_name = zpool.split('/')[0] 

236 if zpool_name in zpools: 

237 raise exception.BadConfigurationException( 

238 reason=_("Using the same zpool twice is prohibited. " 

239 "Duplicate is '%(zpool)s'. List of zpools: " 

240 "%(zpool_list)s.") % { 

241 'zpool': zpool, 

242 'zpool_list': ', '.join( 

243 self.configuration.zfs_zpool_list)}) 

244 zpools.append(zpool_name) 

245 return zpools 

246 

247 @zfs_utils.zfs_dataset_synchronized 

248 def _delete_dataset_or_snapshot_with_retry(self, name): 

249 """Attempts to destroy some dataset or snapshot with retries.""" 

250 # NOTE(vponomaryov): it is possible to see 'dataset is busy' error 

251 # under the load. So, we are ok to perform retry in this case. 

252 mountpoint = self.get_zfs_option(name, 'mountpoint') 

253 if '@' not in name: 

254 # NOTE(vponomaryov): check that dataset has no open files. 

255 start_point = time.time() 

256 while time.time() - start_point < 60: 

257 try: 

258 out, err = self.execute('lsof', '-w', mountpoint) 

259 except exception.ProcessExecutionError: 

260 # NOTE(vponomaryov): lsof returns code 1 if search 

261 # didn't give results. 

262 break 

263 LOG.debug("Cannot destroy dataset '%(name)s', it has " 

264 "opened files. Will wait 2 more seconds. " 

265 "Out: \n%(out)s", { 

266 'name': name, 'out': out}) 

267 time.sleep(2) 

268 else: 

269 raise exception.ZFSonLinuxException( 

270 msg=_("Could not destroy '%s' dataset, " 

271 "because it had opened files.") % name) 

272 

273 @utils.retry(retry_param=exception.ProcessExecutionError, retries=10) 

274 def _zfs_destroy_with_retry(): 

275 """Retry destroying dataset ten times with exponential backoff.""" 

276 # NOTE(bswartz): There appears to be a bug in ZFS when creating and 

277 # destroying datasets concurrently where the filesystem remains 

278 # mounted even though ZFS thinks it's unmounted. The most reliable 

279 # workaround I've found is to force the unmount, then attempt the 

280 # destroy, with short pauses around the unmount. (See bug#1546723) 

281 try: 

282 self.execute('sudo', 'umount', mountpoint) 

283 except exception.ProcessExecutionError: 

284 # Ignore failed umount, it's normal 

285 pass 

286 time.sleep(2) 

287 

288 # NOTE(vponomaryov): Now, when no file usages and mounts of dataset 

289 # exist, destroy dataset. 

290 self.zfs('destroy', '-f', name) 

291 

292 _zfs_destroy_with_retry() 

293 

294 def _setup_helpers(self): 

295 """Setups share helper for ZFS backend.""" 

296 self._helpers = {} 

297 helpers = self.configuration.zfs_share_helpers 

298 if helpers: 

299 for helper_str in helpers: 

300 share_proto, __, import_str = helper_str.partition('=') 

301 helper = importutils.import_class(import_str) 

302 self._helpers[share_proto.upper()] = helper( 

303 self.configuration) 

304 else: 

305 raise exception.BadConfigurationException( 

306 reason=_( 

307 "No share helpers selected for ZFSonLinux Driver. " 

308 "Please specify using config option 'zfs_share_helpers'.")) 

309 

310 def _get_share_helper(self, share_proto): 

311 """Returns share helper specific for used share protocol.""" 

312 helper = self._helpers.get(share_proto) 

313 if helper: 

314 return helper 

315 else: 

316 raise exception.InvalidShare( 

317 reason=_("Wrong, unsupported or disabled protocol - " 

318 "'%s'.") % share_proto) 

319 

320 def do_setup(self, context): 

321 """Perform basic setup and checks.""" 

322 super(ZFSonLinuxShareDriver, self).do_setup(context) 

323 self._setup_helpers() 

324 for ip in (self.share_export_ip, self.service_ip): 

325 if not utils.is_valid_ip_address(ip, 4): 

326 raise exception.BadConfigurationException( 

327 reason=_("Wrong IP address provided: " 

328 "%s") % self.share_export_ip) 

329 

330 if not self.zpool_list: 

331 raise exception.BadConfigurationException( 

332 reason=_("No zpools specified for usage: " 

333 "%s") % self.zpool_list) 

334 

335 # Make pool mounts shared so that cloned namespaces receive unmounts 

336 # and don't prevent us from unmounting datasets 

337 for zpool in self.configuration.zfs_zpool_list: 

338 self.execute('sudo', 'mount', '--make-rshared', ('/%s' % zpool)) 

339 

340 if self.configuration.zfs_use_ssh: 

341 # Check workability of SSH executor 

342 self.ssh_executor('whoami') 

343 

344 def _get_pools_info(self): 

345 """Returns info about all pools used by backend.""" 

346 pools = [] 

347 for zpool in self.zpool_list: 

348 free_size = self.get_zpool_option(zpool, 'free') 

349 free_size = utils.translate_string_size_to_float(free_size) 

350 total_size = self.get_zpool_option(zpool, 'size') 

351 total_size = utils.translate_string_size_to_float(total_size) 

352 pool = { 

353 'pool_name': zpool, 

354 'total_capacity_gb': float(total_size), 

355 'free_capacity_gb': float(free_size), 

356 'reserved_percentage': 

357 self.configuration.reserved_share_percentage, 

358 'reserved_snapshot_percentage': ( 

359 self.configuration.reserved_share_from_snapshot_percentage 

360 or self.configuration.reserved_share_percentage), 

361 'reserved_share_extend_percentage': ( 

362 self.configuration.reserved_share_extend_percentage 

363 or self.configuration.reserved_share_percentage), 

364 } 

365 pool.update(self.common_capabilities) 

366 if self.configuration.replication_domain: 

367 pool['replication_type'] = 'readable' 

368 pools.append(pool) 

369 return pools 

370 

371 def _update_share_stats(self): 

372 """Retrieves share stats info.""" 

373 data = { 

374 'share_backend_name': self.backend_name, 

375 'storage_protocol': 'NFS', 

376 'reserved_percentage': 

377 self.configuration.reserved_share_percentage, 

378 'reserved_snapshot_percentage': ( 

379 self.configuration.reserved_share_from_snapshot_percentage 

380 or self.configuration.reserved_share_percentage), 

381 'reserved_share_extend_percentage': ( 

382 self.configuration.reserved_share_extend_percentage 

383 or self.configuration.reserved_share_percentage), 

384 'snapshot_support': True, 

385 'create_share_from_snapshot_support': True, 

386 'driver_name': 'ZFS', 

387 'pools': self._get_pools_info(), 

388 } 

389 if self.configuration.replication_domain: 

390 data['replication_type'] = 'readable' 

391 super(ZFSonLinuxShareDriver, self)._update_share_stats(data) 

392 

393 def _get_share_name(self, share_id): 

394 """Returns name of dataset used for given share.""" 

395 prefix = self.configuration.zfs_dataset_name_prefix or '' 

396 return prefix + share_id.replace('-', '_') 

397 

398 def _get_snapshot_name(self, snapshot_id): 

399 """Returns name of dataset snapshot used for given share snapshot.""" 

400 prefix = self.configuration.zfs_dataset_snapshot_name_prefix or '' 

401 return prefix + snapshot_id.replace('-', '_') 

402 

403 def _get_dataset_creation_options(self, share, is_readonly=False): 

404 """Returns list of options to be used for dataset creation.""" 

405 options = ['quota=%sG' % share['size']] 

406 extra_specs = share_types.get_extra_specs_from_share(share) 

407 

408 dedupe_set = False 

409 dedupe = extra_specs.get('dedupe') 

410 if dedupe: 

411 dedupe = strutils.bool_from_string( 

412 dedupe.lower().split(' ')[-1], default=dedupe) 

413 if (dedupe in self.common_capabilities['dedupe']): 

414 options.append('dedup=%s' % ('on' if dedupe else 'off')) 

415 dedupe_set = True 

416 else: 

417 raise exception.ZFSonLinuxException(msg=_( 

418 "Cannot use requested '%(requested)s' value of 'dedupe' " 

419 "extra spec. It does not fit allowed value '%(allowed)s' " 

420 "that is configured for backend.") % { 

421 'requested': dedupe, 

422 'allowed': self.common_capabilities['dedupe']}) 

423 

424 compression_set = False 

425 compression_type = extra_specs.get('zfsonlinux:compression') 

426 if compression_type: 

427 if (compression_type == 'off' and 

428 False in self.common_capabilities['compression']): 

429 options.append('compression=off') 

430 compression_set = True 

431 elif (compression_type != 'off' and 

432 True in self.common_capabilities['compression']): 

433 options.append('compression=%s' % compression_type) 

434 compression_set = True 

435 else: 

436 raise exception.ZFSonLinuxException(msg=_( 

437 "Cannot use value '%s' of extra spec " 

438 "'zfsonlinux:compression' because compression is disabled " 

439 "for this backend. Set extra spec 'compression=True' to " 

440 "make scheduler pick up appropriate backend." 

441 ) % compression_type) 

442 

443 for option in self.dataset_creation_options or []: 

444 if any(v in option for v in ( 

445 'readonly', 'sharenfs', 'sharesmb', 'quota')): 

446 continue 

447 if 'dedup' in option and dedupe_set is True: 

448 continue 

449 if 'compression' in option and compression_set is True: 

450 continue 

451 options.append(option) 

452 if is_readonly: 

453 options.append('readonly=on') 

454 else: 

455 options.append('readonly=off') 

456 return options 

457 

458 def _get_dataset_name(self, share): 

459 """Returns name of dataset used for given share.""" 

460 pool_name = share_utils.extract_host(share['host'], level='pool') 

461 

462 # Pick pool with nested dataset name if set up 

463 for pool in self.configuration.zfs_zpool_list: 

464 pool_data = pool.split('/') 

465 if (pool_name == pool_data[0] and len(pool_data) > 1): 

466 pool_name = pool 

467 if pool_name[-1] == '/': 

468 pool_name = pool_name[0:-1] 

469 break 

470 

471 dataset_name = self._get_share_name(share['id']) 

472 full_dataset_name = '%(pool)s/%(dataset)s' % { 

473 'pool': pool_name, 'dataset': dataset_name} 

474 

475 return full_dataset_name 

476 

477 @ensure_share_server_not_provided 

478 def create_share(self, context, share, share_server=None): 

479 """Is called to create a share.""" 

480 options = self._get_dataset_creation_options(share, is_readonly=False) 

481 cmd = ['create'] 

482 for option in options: 

483 cmd.extend(['-o', option]) 

484 dataset_name = self._get_dataset_name(share) 

485 cmd.append(dataset_name) 

486 

487 ssh_cmd = '%(username)s@%(host)s' % { 

488 'username': self.configuration.zfs_ssh_username, 

489 'host': self.service_ip, 

490 } 

491 pool_name = share_utils.extract_host(share['host'], level='pool') 

492 self.private_storage.update( 

493 share['id'], { 

494 'entity_type': 'share', 

495 'dataset_name': dataset_name, 

496 'ssh_cmd': ssh_cmd, # used with replication and migration 

497 'pool_name': pool_name, # used in replication 

498 'used_options': ' '.join(options), 

499 } 

500 ) 

501 

502 self.zfs(*cmd) 

503 

504 return self._get_share_helper( 

505 share['share_proto']).create_exports(dataset_name) 

506 

507 @ensure_share_server_not_provided 

508 def delete_share(self, context, share, share_server=None): 

509 """Is called to remove a share.""" 

510 pool_name = self.private_storage.get(share['id'], 'pool_name') 

511 pool_name = pool_name or share_utils.extract_host( 

512 share["host"], level="pool") 

513 dataset_name = self.private_storage.get(share['id'], 'dataset_name') 

514 if not dataset_name: 

515 dataset_name = self._get_dataset_name(share) 

516 

517 out, err = self.zfs('list', '-r', pool_name) 

518 data = self.parse_zfs_answer(out) 

519 for datum in data: 

520 if datum['NAME'] != dataset_name: 

521 continue 

522 

523 # Delete dataset's snapshots first 

524 out, err = self.zfs('list', '-r', '-t', 'snapshot', pool_name) 

525 snapshots = self.parse_zfs_answer(out) 

526 full_snapshot_prefix = ( 

527 dataset_name + '@') 

528 for snap in snapshots: 

529 if full_snapshot_prefix in snap['NAME']: 

530 self._delete_dataset_or_snapshot_with_retry(snap['NAME']) 

531 

532 self._get_share_helper( 

533 share['share_proto']).remove_exports(dataset_name) 

534 self._delete_dataset_or_snapshot_with_retry(dataset_name) 

535 break 

536 else: 

537 LOG.warning( 

538 "Share with '%(id)s' ID and '%(name)s' NAME is " 

539 "absent on backend. Nothing has been deleted.", 

540 {'id': share['id'], 'name': dataset_name}) 

541 self.private_storage.delete(share['id']) 

542 

543 @ensure_share_server_not_provided 

544 def create_snapshot(self, context, snapshot, share_server=None): 

545 """Is called to create a snapshot.""" 

546 dataset_name = self.private_storage.get( 

547 snapshot['share_instance_id'], 'dataset_name') 

548 snapshot_tag = self._get_snapshot_name(snapshot['id']) 

549 snapshot_name = dataset_name + '@' + snapshot_tag 

550 self.private_storage.update( 

551 snapshot['snapshot_id'], { 

552 'entity_type': 'snapshot', 

553 'snapshot_tag': snapshot_tag, 

554 } 

555 ) 

556 self.zfs('snapshot', snapshot_name) 

557 return {"provider_location": snapshot_name} 

558 

559 @ensure_share_server_not_provided 

560 def delete_snapshot(self, context, snapshot, share_server=None): 

561 """Is called to remove a snapshot.""" 

562 self._delete_snapshot(context, snapshot) 

563 self.private_storage.delete(snapshot['snapshot_id']) 

564 

565 def _get_saved_snapshot_name(self, snapshot_instance): 

566 snapshot_tag = self.private_storage.get( 

567 snapshot_instance['snapshot_id'], 'snapshot_tag') 

568 dataset_name = self.private_storage.get( 

569 snapshot_instance['share_instance_id'], 'dataset_name') 

570 snapshot_name = dataset_name + '@' + snapshot_tag 

571 return snapshot_name 

572 

573 def _delete_snapshot(self, context, snapshot): 

574 snapshot_name = self._get_saved_snapshot_name(snapshot) 

575 out, err = self.zfs('list', '-r', '-t', 'snapshot', snapshot_name) 

576 data = self.parse_zfs_answer(out) 

577 for datum in data: 

578 if datum['NAME'] == snapshot_name: 

579 self._delete_dataset_or_snapshot_with_retry(snapshot_name) 

580 break 

581 else: 

582 LOG.warning( 

583 "Snapshot with '%(id)s' ID and '%(name)s' NAME is " 

584 "absent on backend. Nothing has been deleted.", 

585 {'id': snapshot['id'], 'name': snapshot_name}) 

586 

587 @ensure_share_server_not_provided 

588 def create_share_from_snapshot(self, context, share, snapshot, 

589 share_server=None, parent_share=None): 

590 """Is called to create a share from snapshot.""" 

591 src_backend_name = share_utils.extract_host( 

592 snapshot.share_instance['host'], level='backend_name' 

593 ) 

594 src_snapshot_name = self._get_saved_snapshot_name(snapshot) 

595 dataset_name = self._get_dataset_name(share) 

596 

597 dst_backend_ssh_cmd = '%(username)s@%(host)s' % { 

598 'username': self.configuration.zfs_ssh_username, 

599 'host': self.service_ip, 

600 } 

601 

602 dst_backend_pool_name = share_utils.extract_host(share['host'], 

603 level='pool') 

604 options = self._get_dataset_creation_options(share, is_readonly=False) 

605 

606 self.private_storage.update( 

607 share['id'], { 

608 'entity_type': 'share', 

609 'dataset_name': dataset_name, 

610 'ssh_cmd': dst_backend_ssh_cmd, # used in replication 

611 'pool_name': dst_backend_pool_name, # used in replication 

612 'used_options': options, 

613 } 

614 ) 

615 

616 # NOTE(andrebeltrami): Implementing the support for create share 

617 # from snapshot in different backends in different hosts 

618 src_config = get_backend_configuration(src_backend_name) 

619 src_backend_ssh_cmd = '%(username)s@%(host)s' % { 

620 'username': src_config.zfs_ssh_username, 

621 'host': src_config.zfs_service_ip, 

622 } 

623 self.execute( 

624 # NOTE(vponomaryov): SSH is used as workaround for 'execute' 

625 # implementation restriction that does not support usage 

626 # of '|'. 

627 'ssh', src_backend_ssh_cmd, 

628 'sudo', 'zfs', 'send', '-vD', src_snapshot_name, '|', 

629 'ssh', dst_backend_ssh_cmd, 

630 'sudo', 'zfs', 'receive', '-v', dataset_name, 

631 ) 

632 

633 # Apply options based on used share type that may differ from 

634 # one used for original share. 

635 for option in options: 

636 self.zfs('set', option, dataset_name) 

637 

638 # Delete with retry as right after creation it may be temporary busy. 

639 self.execute_with_retry( 

640 'sudo', 'zfs', 'destroy', 

641 dataset_name + '@' + src_snapshot_name.split('@')[-1]) 

642 

643 return self._get_share_helper( 

644 share['share_proto']).create_exports(dataset_name) 

645 

646 def get_pool(self, share): 

647 """Return pool name where the share resides on. 

648 

649 :param share: The share hosted by the driver. 

650 """ 

651 pool_name = share_utils.extract_host(share['host'], level='pool') 

652 return pool_name 

653 

654 @ensure_share_server_not_provided 

655 def ensure_share(self, context, share, share_server=None): 

656 """Invoked to ensure that given share is exported.""" 

657 dataset_name = self.private_storage.get(share['id'], 'dataset_name') 

658 if not dataset_name: 

659 dataset_name = self._get_dataset_name(share) 

660 

661 pool_name = share_utils.extract_host(share['host'], level='pool') 

662 out, err = self.zfs('list', '-r', pool_name) 

663 data = self.parse_zfs_answer(out) 

664 for datum in data: 

665 if datum['NAME'] == dataset_name: 

666 ssh_cmd = '%(username)s@%(host)s' % { 

667 'username': self.configuration.zfs_ssh_username, 

668 'host': self.service_ip, 

669 } 

670 self.private_storage.update( 

671 share['id'], {'ssh_cmd': ssh_cmd}) 

672 sharenfs = self.get_zfs_option(dataset_name, 'sharenfs') 

673 if sharenfs != 'off': 

674 self.zfs('share', dataset_name) 

675 export_locations = self._get_share_helper( 

676 share['share_proto']).get_exports(dataset_name) 

677 return export_locations 

678 else: 

679 raise exception.ShareResourceNotFound(share_id=share['id']) 

680 

681 def get_network_allocations_number(self): 

682 """ZFS does not handle networking. Return 0.""" 

683 return 0 

684 

685 @ensure_share_server_not_provided 

686 def extend_share(self, share, new_size, share_server=None): 

687 """Extends size of existing share.""" 

688 dataset_name = self._get_dataset_name(share) 

689 self.zfs('set', 'quota=%sG' % new_size, dataset_name) 

690 

691 @ensure_share_server_not_provided 

692 def shrink_share(self, share, new_size, share_server=None): 

693 """Shrinks size of existing share.""" 

694 dataset_name = self._get_dataset_name(share) 

695 consumed_space = self.get_zfs_option(dataset_name, 'used') 

696 consumed_space = utils.translate_string_size_to_float(consumed_space) 

697 if consumed_space >= new_size: 

698 raise exception.ShareShrinkingPossibleDataLoss( 

699 share_id=share['id']) 

700 self.zfs('set', 'quota=%sG' % new_size, dataset_name) 

701 

702 @ensure_share_server_not_provided 

703 def update_access(self, context, share, access_rules, add_rules, 

704 delete_rules, update_rules, share_server=None): 

705 """Updates access rules for given share.""" 

706 dataset_name = self._get_dataset_name(share) 

707 executor = self._get_shell_executor_by_host(share['host']) 

708 return self._get_share_helper(share['share_proto']).update_access( 

709 dataset_name, access_rules, add_rules, delete_rules, 

710 executor=executor) 

711 

712 def manage_existing(self, share, driver_options): 

713 """Manage existing ZFS dataset as manila share. 

714 

715 ZFSonLinux driver accepts only one driver_option 'size'. 

716 If an administrator provides this option, then such quota will be set 

717 to dataset and used as share size. Otherwise, driver will set quota 

718 equal to nearest bigger rounded integer of usage size. 

719 Driver does not expect mountpoint to be changed (should be equal 

720 to default that is "/%(dataset_name)s"). 

721 

722 :param share: share data 

723 :param driver_options: Empty dict or dict with 'size' option. 

724 :return: dict with share size and its export locations. 

725 """ 

726 old_export_location = share["export_locations"][0]["path"] 

727 old_dataset_name = old_export_location.split(":/")[-1] 

728 

729 scheduled_pool_name = share_utils.extract_host( 

730 share["host"], level="pool") 

731 actual_pool_name = old_dataset_name.split("/")[0] 

732 

733 new_dataset_name = self._get_dataset_name(share) 

734 

735 # Calculate quota for managed dataset 

736 quota = driver_options.get("size") 

737 if not quota: 

738 consumed_space = self.get_zfs_option(old_dataset_name, "used") 

739 consumed_space = utils.translate_string_size_to_float( 

740 consumed_space) 

741 quota = int(consumed_space) + 1 

742 share["size"] = int(quota) 

743 

744 # Save dataset-specific data in private storage 

745 options = self._get_dataset_creation_options(share, is_readonly=False) 

746 ssh_cmd = "%(username)s@%(host)s" % { 

747 "username": self.configuration.zfs_ssh_username, 

748 "host": self.service_ip, 

749 } 

750 

751 # Perform checks on requested dataset 

752 if actual_pool_name != scheduled_pool_name: 

753 raise exception.ZFSonLinuxException( 

754 _("Cannot manage share '%(share_id)s' " 

755 "(share_instance '%(si_id)s'), because scheduled " 

756 "pool '%(sch)s' and actual '%(actual)s' differ.") % { 

757 "share_id": share["share_id"], 

758 "si_id": share["id"], 

759 "sch": scheduled_pool_name, 

760 "actual": actual_pool_name}) 

761 

762 out, err = self.zfs("list", "-r", actual_pool_name) 

763 data = self.parse_zfs_answer(out) 

764 for datum in data: 

765 if datum["NAME"] == old_dataset_name: 

766 break 

767 else: 

768 raise exception.ZFSonLinuxException( 

769 _("Cannot manage share '%(share_id)s' " 

770 "(share_instance '%(si_id)s'), because dataset " 

771 "'%(dataset)s' not found in zpool '%(zpool)s'.") % { 

772 "share_id": share["share_id"], 

773 "si_id": share["id"], 

774 "dataset": old_dataset_name, 

775 "zpool": actual_pool_name}) 

776 

777 # Unmount the dataset before attempting to rename and mount 

778 try: 

779 self._unmount_share_with_retry(old_dataset_name) 

780 except exception.ZFSonLinuxException: 

781 msg = _("Unable to unmount share before renaming and re-mounting.") 

782 raise exception.ZFSonLinuxException(message=msg) 

783 

784 # Rename the dataset and mount with new name 

785 self.zfs_with_retry("rename", old_dataset_name, new_dataset_name) 

786 

787 try: 

788 self.zfs("mount", new_dataset_name) 

789 except exception.ProcessExecutionError: 

790 # Workaround for bug/1785180 

791 out, err = self.zfs("mount") 

792 mounted = any([new_dataset_name in mountedfs 

793 for mountedfs in out.splitlines()]) 

794 if not mounted: 

795 raise 

796 

797 # Apply options to dataset 

798 for option in options: 

799 self.zfs("set", option, new_dataset_name) 

800 

801 # Get new export locations of renamed dataset 

802 export_locations = self._get_share_helper( 

803 share["share_proto"]).get_exports(new_dataset_name) 

804 

805 self.private_storage.update( 

806 share["id"], { 

807 "entity_type": "share", 

808 "dataset_name": new_dataset_name, 

809 "ssh_cmd": ssh_cmd, # used in replication 

810 "pool_name": actual_pool_name, # used in replication 

811 "used_options": " ".join(options), 

812 } 

813 ) 

814 

815 return {"size": share["size"], "export_locations": export_locations} 

816 

817 def unmanage(self, share): 

818 """Removes the specified share from Manila management.""" 

819 self.private_storage.delete(share['id']) 

820