Coverage for manila/share/drivers/service_instance.py: 96%

1# Copyright (c) 2014 NetApp, Inc. 

2# Copyright (c) 2015 Mirantis, Inc. 

3# All Rights Reserved. 

4# 

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

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

7# a copy of the License at 

8# 

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

10# 

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

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

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

14# License for the specific language governing permissions and limitations 

15# under the License. 

16 

17"""Module for managing nova instances for share drivers.""" 

18 

19import abc 

20import os 

21import time 

22 

23import netaddr 

24from oslo_config import cfg 

25from oslo_log import log 

26from oslo_utils import importutils 

27from oslo_utils import netutils 

28 

29from manila.common import constants as const 

30from manila import compute 

31from manila import context 

32from manila import coordination 

33from manila import exception 

34from manila.i18n import _ 

35from manila import image 

36from manila.network.linux import ip_lib 

37from manila.network.neutron import api as neutron 

38from manila import ssh_utils 

39from manila import utils 

40from manila import volume 

41 

42LOG = log.getLogger(__name__) 

43NEUTRON_NAME = "neutron" 

44 

45share_servers_handling_mode_opts = [ 

46 cfg.StrOpt( 

47 "service_image_name", 

48 default="manila-service-image", 

49 help="Name of image in Glance, that will be used for service instance " 

50 "creation. Only used if driver_handles_share_servers=True."), 

51 cfg.StrOpt( 

52 "service_instance_name_template", 

53 default="%s", 

54 help="Name of service instance. " 

55 "Only used if driver_handles_share_servers=True."), 

56 cfg.StrOpt( 

57 "manila_service_keypair_name", 

58 default="manila-service", 

59 help="Keypair name that will be created and used for service " 

60 "instances. Only used if driver_handles_share_servers=True."), 

61 cfg.StrOpt( 

62 "path_to_public_key", 

63 default="~/.ssh/id_rsa.pub", 

64 help="Path to hosts public key. " 

65 "Only used if driver_handles_share_servers=True."), 

66 cfg.StrOpt( 

67 "service_instance_security_group", 

68 default="manila-service", 

69 help="Security group name, that will be used for " 

70 "service instance creation. " 

71 "Only used if driver_handles_share_servers=True."), 

72 cfg.StrOpt( 

73 "service_instance_flavor_id", 

74 default="100", 

75 help="ID of flavor, that will be used for service instance " 

76 "creation. Only used if driver_handles_share_servers=True."), 

77 cfg.StrOpt( 

78 "service_network_name", 

79 default="manila_service_network", 

80 help="Name of manila service network. Used only with Neutron. " 

81 "Only used if driver_handles_share_servers=True."), 

82 cfg.HostAddressOpt( 

83 "service_network_host", 

84 sample_default="<your_network_hostname>", 

85 help="Hostname to be used for service network binding. Used only with " 

86 "Neutron and if driver_handles_share_servers=True."), 

87 cfg.StrOpt( 

88 "service_network_cidr", 

89 default="10.254.0.0/16", 

90 help="CIDR of manila service network. Used only with Neutron and " 

91 "if driver_handles_share_servers=True."), 

92 cfg.IntOpt( 

93 "service_network_division_mask", 

94 default=28, 

95 help="This mask is used for dividing service network into " 

96 "subnets, IP capacity of subnet with this mask directly " 

97 "defines possible amount of created service VMs " 

98 "per tenant's subnet. Used only with Neutron " 

99 "and if driver_handles_share_servers=True."), 

100 cfg.StrOpt( 

101 "interface_driver", 

102 default="manila.network.linux.interface.OVSInterfaceDriver", 

103 help="Module path to the Virtual Interface (VIF) driver class. This " 

104 "option is used only by drivers operating in " 

105 "`driver_handles_share_servers=True` mode that provision " 

106 "OpenStack compute instances as share servers. This option is " 

107 "only supported with Neutron networking. " 

108 "Drivers provided in tree work with Linux Bridge " 

109 "(manila.network.linux.interface.BridgeInterfaceDriver) and OVS " 

110 "(manila.network.linux.interface.OVSInterfaceDriver). If the " 

111 "manila-share service is running on a host that is connected to " 

112 "the administrator network, a no-op driver " 

113 "(manila.network.linux.interface.NoopInterfaceDriver) may " 

114 "be used."), 

115 cfg.BoolOpt( 

116 "connect_share_server_to_tenant_network", 

117 default=False, 

118 help="Attach share server directly to share network. " 

119 "Used only with Neutron and " 

120 "if driver_handles_share_servers=True."), 

121 cfg.StrOpt( 

122 "admin_network_id", 

123 help="ID of neutron network used to communicate with admin network," 

124 " to create additional admin export locations on."), 

125 cfg.StrOpt( 

126 "admin_subnet_id", 

127 help="ID of neutron subnet used to communicate with admin network," 

128 " to create additional admin export locations on. " 

129 "Related to 'admin_network_id'."), 

130 cfg.BoolOpt( 

131 'service_instance_boot_from_volume', 

132 default=False, 

133 help='Boot service instances (share servers) from a Cinder volume. ' 

134 'If False, boot from the image as before. ' 

135 'Only used if driver_handles_share_servers=True.' 

136 ), 

137 cfg.IntOpt( 

138 'service_instance_boot_volume_size', 

139 default=10, 

140 min=1, 

141 help='Size (GiB) of the root volume when booting from volume. ' 

142 'Only used if driver_handles_share_servers=True.' 

143 ), 

144 cfg.StrOpt( 

145 'service_instance_boot_volume_type', 

146 help='Name or id of cinder volume type which will be used ' 

147 'for all boot volumes created by driver.'), 

148 cfg.StrOpt( 

149 'service_instance_base_boot_volume_id', 

150 help="UUID of volume in Cinder, that will be used as base volume " 

151 "that bootable volume clone from during service instance " 

152 "creation. Only used if driver_handles_share_servers=True."), 

153 cfg.BoolOpt( 

154 'service_instance_boot_volume_delete_on_termination', 

155 default=True, 

156 help='Whether the root volume is deleted when the service instance ' 

157 'is terminated. Only used if driver_handles_share_servers=True.' 

158 ), 

159 cfg.StrOpt('service_instance_boot_volume_name_template', 

160 default='manila-share-%s-boot', 

161 help="Boot volume name template."), 

162] 

163 

164no_share_servers_handling_mode_opts = [ 

165 cfg.StrOpt( 

166 "service_instance_name_or_id", 

167 help="Name or ID of service instance in Nova to use for share " 

168 "exports. Used only when share servers handling is disabled."), 

169 cfg.HostAddressOpt( 

170 "service_net_name_or_ip", 

171 help="Can be either name of network that is used by service " 

172 "instance within Nova to get IP address or IP address itself " 

173 "(either IPv4 or IPv6) for managing shares there. " 

174 "Used only when share servers handling is disabled."), 

175 cfg.HostAddressOpt( 

176 "tenant_net_name_or_ip", 

177 help="Can be either name of network that is used by service " 

178 "instance within Nova to get IP address or IP address itself " 

179 "(either IPv4 or IPv6) for exporting shares. " 

180 "Used only when share servers handling is disabled."), 

181] 

182 

183common_opts = [ 

184 cfg.StrOpt( 

185 "service_instance_user", 

186 help="User in service instance that will be used for authentication."), 

187 cfg.StrOpt( 

188 "service_instance_password", 

189 secret=True, 

190 help="Password for service instance user."), 

191 cfg.StrOpt( 

192 "path_to_private_key", 

193 help="Path to host's private key."), 

194 cfg.IntOpt( 

195 "max_time_to_build_instance", 

196 default=300, 

197 help="Maximum time in seconds to wait for creating service instance."), 

198 cfg.BoolOpt( 

199 "limit_ssh_access", 

200 default=False, 

201 help="Block SSH connection to the service instance from other " 

202 "networks than service network."), 

203] 

204 

205CONF = cfg.CONF 

206 

207 

208class ServiceInstanceManager(object): 

209 """Manages nova instances for various share drivers. 

210 

211 This class provides following external methods: 

212 

213 1. set_up_service_instance: creates instance and sets up share 

214 infrastructure. 

215 2. ensure_service_instance: ensure service instance is available. 

216 3. delete_service_instance: removes service instance and network 

217 infrastructure. 

218 """ 

219 _INSTANCE_CONNECTION_PROTO = "SSH" 

220 

221 def get_config_option(self, key): 

222 """Returns value of config option. 

223 

224 :param key: key of config' option. 

225 :returns: str -- value of config's option. 

226 first priority is driver's config, 

227 second priority is global config. 

228 """ 

229 if self.driver_config: 

230 return self.driver_config.safe_get(key) 

231 return CONF.get(key) 

232 

233 def _get_network_helper(self): 

234 # Historically, there were multiple types of network helper, 

235 # but currently the only network helper type is Neutron. 

236 return NeutronNetworkHelper(self) 

237 

238 def __init__(self, driver_config=None): 

239 

240 super(ServiceInstanceManager, self).__init__() 

241 self.driver_config = driver_config 

242 

243 if self.driver_config: 

244 self.driver_config.append_config_values(common_opts) 

245 if self.get_config_option("driver_handles_share_servers"): 

246 self.driver_config.append_config_values( 

247 share_servers_handling_mode_opts) 

248 else: 

249 self.driver_config.append_config_values( 

250 no_share_servers_handling_mode_opts) 

251 else: 

252 CONF.register_opts(common_opts) 

253 if self.get_config_option("driver_handles_share_servers"): 

254 CONF.register_opts(share_servers_handling_mode_opts) 

255 else: 

256 CONF.register_opts(no_share_servers_handling_mode_opts) 

257 

258 if not self.get_config_option("service_instance_user"): 

259 raise exception.ServiceInstanceException( 

260 _('Service instance user is not specified.')) 

261 self.admin_context = context.get_admin_context() 

262 

263 self.image_api = image.API() 

264 self.compute_api = compute.API() 

265 self.volume_api = volume.API() 

266 

267 self.path_to_private_key = self.get_config_option( 

268 "path_to_private_key") 

269 self.max_time_to_build_instance = self.get_config_option( 

270 "max_time_to_build_instance") 

271 

272 self.availability_zone = self.get_config_option( 

273 'backend_availability_zone') or CONF.storage_availability_zone 

274 

275 if self.get_config_option("driver_handles_share_servers"): 

276 self.path_to_public_key = self.get_config_option( 

277 "path_to_public_key") 

278 self._network_helper = None 

279 

280 @property 

281 @utils.synchronized("instantiate_network_helper") 

282 def network_helper(self): 

283 if not self._network_helper: 

284 self._network_helper = self._get_network_helper() 

285 self._network_helper.setup_connectivity_with_service_instances() 

286 return self._network_helper 

287 

288 def get_common_server(self): 

289 data = { 

290 'public_address': None, 

291 'private_address': None, 

292 'service_net_name_or_ip': self.get_config_option( 

293 'service_net_name_or_ip'), 

294 'tenant_net_name_or_ip': self.get_config_option( 

295 'tenant_net_name_or_ip'), 

296 } 

297 

298 data['instance'] = self.compute_api.server_get_by_name_or_id( 

299 self.admin_context, 

300 self.get_config_option('service_instance_name_or_id')) 

301 

302 if netutils.is_valid_ip(data['service_net_name_or_ip']): 

303 data['private_address'] = [data['service_net_name_or_ip']] 

304 else: 

305 data['private_address'] = self._get_addresses_by_network_name( 

306 data['service_net_name_or_ip'], data['instance']) 

307 

308 if netutils.is_valid_ip(data['tenant_net_name_or_ip']): 

309 data['public_address'] = [data['tenant_net_name_or_ip']] 

310 else: 

311 data['public_address'] = self._get_addresses_by_network_name( 

312 data['tenant_net_name_or_ip'], data['instance']) 

313 

314 if not (data['public_address'] and data['private_address']): 

315 raise exception.ManilaException( 

316 "Can not find one of net addresses for service instance. " 

317 "Instance: %(instance)s, " 

318 "private_address: %(private_address)s, " 

319 "public_address: %(public_address)s." % data) 

320 

321 share_server = { 

322 'username': self.get_config_option('service_instance_user'), 

323 'password': self.get_config_option('service_instance_password'), 

324 'pk_path': self.path_to_private_key, 

325 'instance_id': data['instance']['id'], 

326 } 

327 for key in ('private_address', 'public_address'): 

328 data[key + '_first'] = None 

329 for address in data[key]: 329 ↛ 327line 329 didn't jump to line 327 because the loop on line 329 didn't complete

330 if netutils.is_valid_ip(address): 

331 data[key + '_first'] = address 

332 break 

333 share_server['ip'] = data['private_address_first'] 

334 share_server['public_address'] = data['public_address_first'] 

335 return {'backend_details': share_server} 

336 

337 def _get_addresses_by_network_name(self, net_name, server): 

338 net_ips = [] 

339 if 'networks' in server and net_name in server['networks']: 

340 net_ips = server['networks'][net_name] 

341 elif 'addresses' in server and net_name in server['addresses']: 

342 net_ips = [addr['addr'] for addr in server['addresses'][net_name]] 

343 return net_ips 

344 

345 def _get_service_instance_name(self, share_server_id): 

346 """Returns service vms name.""" 

347 if self.driver_config and self.driver_config.config_group: 

348 # Make service instance name unique for multibackend installation 

349 name = "%s_%s" % (self.driver_config.config_group, share_server_id) 

350 else: 

351 name = share_server_id 

352 return self.get_config_option("service_instance_name_template") % name 

353 

354 def _get_server_ip(self, server, net_name): 

355 """Returns service IP address of service instance.""" 

356 net_ips = self._get_addresses_by_network_name(net_name, server) 

357 if not net_ips: 

358 msg = _("Failed to get service instance IP address. " 

359 "Service network name is '%(net_name)s' " 

360 "and provided data are '%(data)s'.") 

361 msg = msg % {'net_name': net_name, 'data': str(server)} 

362 raise exception.ServiceInstanceException(msg) 

363 return net_ips[0] 

364 

365 def _get_or_create_security_groups(self, context, name=None, 

366 description=None, 

367 allow_ssh_subnet=False): 

368 """Get or create security group for service_instance. 

369 

370 :param context: context, that should be used 

371 :param name: this is used for selection/creation of sec.group 

372 :param description: this is used on sec.group creation step only 

373 :param allow_ssh_subnet: subnet details to allow ssh connection from, 

374 if not supplied ssh will be allowed from any host 

375 :returns: SecurityGroup -- security group instance from Nova 

376 :raises: exception.ServiceInstanceException. 

377 """ 

378 

379 sgs = [] 

380 # Common security group 

381 name = name or self.get_config_option( 

382 "service_instance_security_group") 

383 if not name: 

384 LOG.warning("Name for service instance security group is not " 

385 "provided. Skipping security group step.") 

386 return None 

387 if not description: 

388 description = ("This security group is intended " 

389 "to be used by share service.") 

390 sec_group_data = const.SERVICE_INSTANCE_SECGROUP_DATA 

391 if not allow_ssh_subnet: 

392 sec_group_data += const.SSH_PORTS 

393 

394 sgs.append(self._get_or_create_security_group(name, description, 

395 sec_group_data)) 

396 if allow_ssh_subnet: 

397 if "cidr" not in allow_ssh_subnet or 'id' not in allow_ssh_subnet: 

398 raise exception.ManilaException( 

399 "Unable to limit SSH access") 

400 ssh_sg_name = "manila-service-subnet-{}".format( 

401 allow_ssh_subnet["id"]) 

402 sgs.append(self._get_or_create_security_group( 

403 ssh_sg_name, description, 

404 const.SSH_PORTS, allow_ssh_subnet["cidr"])) 

405 return sgs 

406 

407 @utils.synchronized( 

408 "service_instance_get_or_create_security_group", external=True) 

409 def _get_or_create_security_group(self, name, 

410 description, sec_group_data, 

411 cidr="0.0.0.0/0"): 

412 s_groups = self.network_helper.neutron_api.security_group_list({ 

413 "name": name, 

414 })['security_groups'] 

415 s_groups = [s for s in s_groups if s['name'] == name] 

416 if not s_groups: 

417 LOG.debug("Creating security group with name '%s'.", name) 

418 sg = self.network_helper.neutron_api.security_group_create( 

419 name, description)['security_group'] 

420 for protocol, ports in sec_group_data: 

421 self.network_helper.neutron_api.security_group_rule_create( 

422 parent_group_id=sg['id'], 

423 ip_protocol=protocol, 

424 from_port=ports[0], 

425 to_port=ports[1], 

426 cidr=cidr, 

427 ) 

428 elif len(s_groups) > 1: 

429 msg = _("Ambiguous security_groups.") 

430 raise exception.ServiceInstanceException(msg) 

431 else: 

432 sg = s_groups[0] 

433 return sg 

434 

435 def ensure_service_instance(self, context, server): 

436 """Ensures that server exists and active.""" 

437 if 'instance_id' not in server: 

438 LOG.warning("Unable to check server existence since " 

439 "'instance_id' key is not set in share server " 

440 "backend details.") 

441 return False 

442 try: 

443 inst = self.compute_api.server_get(self.admin_context, 

444 server['instance_id']) 

445 except exception.InstanceNotFound: 

446 LOG.warning("Service instance %s does not exist.", 

447 server['instance_id']) 

448 return False 

449 if inst['status'] == 'ACTIVE': 

450 return self._check_server_availability(server) 

451 return False 

452 

453 def _delete_server(self, context, server_id): 

454 """Deletes the server.""" 

455 try: 

456 self.compute_api.server_get(context, server_id) 

457 except exception.InstanceNotFound: 

458 LOG.debug("Service instance '%s' was not found. " 

459 "Nothing to delete, skipping.", server_id) 

460 return 

461 

462 self.compute_api.server_delete(context, server_id) 

463 

464 t = time.time() 

465 while time.time() - t < self.max_time_to_build_instance: 

466 try: 

467 inst = self.compute_api.server_get(context, server_id) 

468 if inst.get("status").lower() == "soft_deleted": 

469 LOG.debug("Service instance '%s' was soft-deleted " 

470 "successfully.", server_id) 

471 break 

472 except exception.InstanceNotFound: 

473 LOG.debug("Service instance '%s' was deleted " 

474 "successfully.", server_id) 

475 break 

476 time.sleep(2) 

477 else: 

478 raise exception.ServiceInstanceException( 

479 _("Instance '%(id)s' has not been deleted in %(s)ss. " 

480 "Giving up.") % { 

481 'id': server_id, 's': self.max_time_to_build_instance}) 

482 

483 def set_up_service_instance(self, context, network_info): 

484 """Finds or creates and sets up service vm. 

485 

486 :param context: defines context, that should be used 

487 :param network_info: network info for getting allocations 

488 :returns: dict with service instance details 

489 :raises: exception.ServiceInstanceException 

490 """ 

491 instance_name = self._get_service_instance_name( 

492 network_info['server_id']) 

493 server = self._create_service_instance( 

494 context, instance_name, network_info) 

495 instance_details = self._get_new_instance_details(server) 

496 

497 if not self._check_server_availability(instance_details): 

498 e = exception.ServiceInstanceException( 

499 _('%(conn_proto)s connection has not been ' 

500 'established to %(server)s in %(time)ss. Giving up.') % { 

501 'conn_proto': self._INSTANCE_CONNECTION_PROTO, 

502 'server': server['ip'], 

503 'time': self.max_time_to_build_instance}) 

504 e.detail_data = {'server_details': instance_details} 

505 raise e 

506 

507 return instance_details 

508 

509 def _get_new_instance_details(self, server): 

510 instance_details = { 

511 'instance_id': server['id'], 

512 'ip': server['ip'], 

513 'pk_path': server.get('pk_path'), 

514 'subnet_id': server.get('subnet_id'), 

515 'password': self.get_config_option('service_instance_password'), 

516 'username': self.get_config_option('service_instance_user'), 

517 'public_address': server['public_address'], 

518 } 

519 if server.get('admin_ip'): 519 ↛ 521line 519 didn't jump to line 521 because the condition on line 519 was always true

520 instance_details['admin_ip'] = server['admin_ip'] 

521 if server.get('router_id'): 521 ↛ 523line 521 didn't jump to line 523 because the condition on line 521 was always true

522 instance_details['router_id'] = server['router_id'] 

523 if server.get('service_port_id'): 

524 instance_details['service_port_id'] = server['service_port_id'] 

525 if server.get('public_port_id'): 

526 instance_details['public_port_id'] = server['public_port_id'] 

527 if server.get('admin_port_id'): 527 ↛ 528line 527 didn't jump to line 528 because the condition on line 527 was never true

528 instance_details['admin_port_id'] = server['admin_port_id'] 

529 

530 for key in ('password', 'pk_path', 'subnet_id'): 

531 if not instance_details[key]: 

532 instance_details.pop(key) 

533 return instance_details 

534 

535 def _load_public_key(self, path): 

536 with open(path, 'r') as f: 

537 public_key = f.read() 

538 return public_key 

539 

540 @utils.synchronized("service_instance_get_key", external=True) 

541 def _get_key(self, context): 

542 """Get ssh key. 

543 

544 :param context: defines context, that should be used 

545 :returns: tuple with keypair name and path to private key. 

546 """ 

547 if not (self.path_to_public_key and self.path_to_private_key): 

548 return (None, None) 

549 path_to_public_key = os.path.expanduser(self.path_to_public_key) 

550 path_to_private_key = os.path.expanduser(self.path_to_private_key) 

551 if (not os.path.exists(path_to_public_key) or 

552 not os.path.exists(path_to_private_key)): 

553 return (None, None) 

554 keypair_name = self.get_config_option("manila_service_keypair_name") 

555 keypairs = [k for k in self.compute_api.keypair_list(context) 

556 if k.name == keypair_name] 

557 if len(keypairs) > 1: 

558 raise exception.ServiceInstanceException(_('Ambiguous keypairs.')) 

559 

560 public_key = self._load_public_key(path_to_public_key) 

561 if not keypairs: 

562 keypair = self.compute_api.keypair_import( 

563 context, keypair_name, public_key) 

564 else: 

565 keypair = keypairs[0] 

566 if keypair.public_key != public_key: 

567 LOG.debug('Public key differs from existing keypair. ' 

568 'Creating new keypair.') 

569 self.compute_api.keypair_delete(context, keypair.id) 

570 keypair = self.compute_api.keypair_import( 

571 context, keypair_name, public_key) 

572 

573 return keypair.name, path_to_private_key 

574 

575 def _get_service_image(self, context): 

576 """Returns ID of service image for service vm creating.""" 

577 service_image_name = self.get_config_option("service_image_name") 

578 images = [image.id for image in self.image_api.image_list(context) 

579 if image.name == service_image_name 

580 and image.status == 'active'] 

581 if not images: 

582 raise exception.ServiceInstanceException( 

583 _("Image with name '%s' was not found or is not in " 

584 "'active' state.") % service_image_name) 

585 if len(images) != 1: 

586 raise exception.ServiceInstanceException( 

587 _("Multiple 'active' state images found with name '%s'!") % 

588 service_image_name) 

589 return images[0] 

590 

591 def _build_bdm_from_volume(self, volume_id, delete_on_termination=True): 

592 return [{ 

593 'boot_index': 0, 

594 'uuid': volume_id, 

595 'source_type': 'volume', 

596 'destination_type': 'volume', 

597 'delete_on_termination': bool(delete_on_termination), 

598 }] 

599 

600 def _build_bdm_from_image(self, image_id, size_gb, 

601 delete_on_termination=True): 

602 # Nova will create the volume in Cinder and attach as root 

603 return [{ 

604 'boot_index': 0, 

605 'uuid': image_id, 

606 'source_type': 'image', 

607 'destination_type': 'volume', 

608 'volume_size': int(size_gb), 

609 'delete_on_termination': bool(delete_on_termination), 

610 }] 

611 

612 def _create_service_instance(self, context, instance_name, network_info): 

613 """Creates service vm and sets up networking for it.""" 

614 boot_from_volume = self.get_config_option( 

615 'service_instance_boot_from_volume') 

616 block_device_mapping_v2 = None 

617 boot_volume_id = None 

618 service_image_id = self._get_service_image(context) 

619 if boot_from_volume: 

620 del_root = self.get_config_option( 

621 'service_instance_boot_volume_delete_on_termination') 

622 base_vol_id = self.get_config_option( 

623 "service_instance_base_boot_volume_id") 

624 root_size = self.get_config_option( 

625 'service_instance_boot_volume_size') 

626 if base_vol_id: 

627 msg = "Creating boot volume for share server '%s'." 

628 LOG.debug(msg, network_info['server_id']) 

629 name = self.get_config_option( 

630 'service_instance_boot_volume_name_template' 

631 ) % network_info[ 

632 'server_id'] 

633 

634 volume_info = { 

635 'size': root_size, 

636 'name': name, 

637 'description': '', 

638 'availability_zone': ( 

639 self.availability_zone 

640 ), 

641 'source_volid': base_vol_id 

642 } 

643 vol_type = self.get_config_option( 

644 "service_instance_boot_volume_type") 

645 volume_info['volume_type'] = vol_type 

646 volume = self.volume_api.create(context, **volume_info) 

647 msg_error = _('Failed to create bootable volume') 

648 timeout = self.get_config_option('max_time_to_create_volume') 

649 msg_timeout = ( 

650 _('Volume has not been created in %ss. Giving up') % 

651 timeout 

652 ) 

653 

654 volume = self.volume_api.wait_for_available_volume( 

655 volume, timeout, 

656 msg_error=msg_error, msg_timeout=msg_timeout 

657 ) 

658 boot_volume_id = volume['id'] 

659 block_device_mapping_v2 = self._build_bdm_from_volume( 

660 boot_volume_id, del_root 

661 ) 

662 else: 

663 block_device_mapping_v2 = self._build_bdm_from_image( 

664 service_image_id, 

665 root_size, 

666 delete_on_termination=del_root 

667 ) 

668 

669 key_name, key_path = self._get_key(context) 

670 if not (self.get_config_option("service_instance_password") or 

671 key_name): 

672 raise exception.ServiceInstanceException( 

673 _('Neither service instance password nor key are available.')) 

674 if not key_path: 674 ↛ 675line 674 didn't jump to line 675 because the condition on line 674 was never true

675 LOG.warning( 

676 'No key path is available. May be non-existent key path is ' 

677 'provided. Check path_to_private_key (current value ' 

678 '%(private_path)s) and path_to_public_key (current value ' 

679 '%(public_path)s) in manila configuration file.', dict( 

680 private_path=self.path_to_private_key, 

681 public_path=self.path_to_public_key)) 

682 network_data = self.network_helper.setup_network(network_info) 

683 fail_safe_data = dict( 

684 router_id=network_data.get('router_id'), 

685 subnet_id=network_data.get('subnet_id')) 

686 if network_data.get('service_port'): 

687 fail_safe_data['service_port_id'] = ( 

688 network_data['service_port']['id']) 

689 if network_data.get('public_port'): 

690 fail_safe_data['public_port_id'] = ( 

691 network_data['public_port']['id']) 

692 if network_data.get('admin_port'): 

693 fail_safe_data['admin_port_id'] = ( 

694 network_data['admin_port']['id']) 

695 try: 

696 create_kwargs = self._get_service_instance_create_kwargs() 

697 if boot_from_volume: 

698 create_kwargs[ 

699 'block_device_mapping_v2' 

700 ] = block_device_mapping_v2 

701 create_kwargs['image'] = None 

702 else: 

703 create_kwargs['image'] = service_image_id 

704 service_instance = self.compute_api.server_create( 

705 context, 

706 name=instance_name, 

707 flavor=self.get_config_option("service_instance_flavor_id"), 

708 key_name=key_name, 

709 nics=network_data['nics'], 

710 availability_zone=self.availability_zone, 

711 **create_kwargs) 

712 

713 fail_safe_data['instance_id'] = service_instance['id'] 

714 

715 service_instance = self.wait_for_instance_to_be_active( 

716 service_instance['id'], 

717 self.max_time_to_build_instance) 

718 

719 if self.get_config_option("limit_ssh_access"): 719 ↛ 730line 719 didn't jump to line 730 because the condition on line 719 was always true

720 try: 

721 service_subnet = network_data['service_subnet'] 

722 except KeyError: 

723 LOG.error( 

724 "Unable to limit ssh access to instance id: '%s'!", 

725 fail_safe_data['instance_id']) 

726 raise exception.ManilaException( 

727 "Unable to limit SSH access - " 

728 "invalid service subnet details provided") 

729 else: 

730 service_subnet = False 

731 

732 sec_groups = self._get_or_create_security_groups( 

733 context, allow_ssh_subnet=service_subnet) 

734 

735 for sg in sec_groups: 

736 sg_id = sg['id'] 

737 LOG.debug( 

738 "Adding security group '%(sg)s' to server '%(si)s'.", 

739 dict(sg=sg_id, si=service_instance["id"])) 

740 self.compute_api.add_security_group_to_server( 

741 context, service_instance["id"], sg_id) 

742 

743 ip = (network_data.get('service_port', 

744 network_data.get( 

745 'admin_port'))['fixed_ips']) 

746 service_instance['ip'] = ip[0]['ip_address'] 

747 public_ip = (network_data.get('public_port', network_data.get( 

748 'service_port'))['fixed_ips']) 

749 service_instance['public_address'] = public_ip[0]['ip_address'] 

750 

751 except Exception as e: 

752 e.detail_data = {'server_details': fail_safe_data} 

753 # Clean up boot volume if we created one and instance creation 

754 # failed. If instance was created successfully, the volume is 

755 # attached and will be cleaned up when the instance is deleted. 

756 if boot_volume_id and 'instance_id' not in fail_safe_data: 756 ↛ 757line 756 didn't jump to line 757 because the condition on line 756 was never true

757 LOG.warning("Cleaning up orphaned boot volume %s after " 

758 "service instance creation failure.", 

759 boot_volume_id) 

760 try: 

761 self.volume_api.delete(context, boot_volume_id) 

762 except Exception: 

763 LOG.exception("Failed to delete orphaned boot volume %s.", 

764 boot_volume_id) 

765 raise 

766 

767 service_instance.update(fail_safe_data) 

768 service_instance['pk_path'] = key_path 

769 for pair in [('router', 'router_id'), ('service_subnet', 'subnet_id')]: 

770 if pair[0] in network_data and 'id' in network_data[pair[0]]: 770 ↛ 769line 770 didn't jump to line 769 because the condition on line 770 was always true

771 service_instance[pair[1]] = network_data[pair[0]]['id'] 

772 

773 admin_port = network_data.get('admin_port') 

774 if admin_port: 774 ↛ 783line 774 didn't jump to line 783 because the condition on line 774 was always true

775 try: 

776 service_instance['admin_ip'] = ( 

777 admin_port['fixed_ips'][0]['ip_address']) 

778 except Exception: 

779 msg = _("Admin port is being used but Admin IP was not found.") 

780 LOG.exception(msg) 

781 raise exception.AdminIPNotFound(reason=msg) 

782 

783 return service_instance 

784 

785 def _get_service_instance_create_kwargs(self): 

786 """Specify extra arguments used when creating the service instance. 

787 

788 Classes inheriting the service instance manager can use this to easily 

789 pass extra arguments such as user data or metadata. 

790 """ 

791 return {} 

792 

793 def _check_server_availability(self, instance_details, interval=5): 

794 t = time.time() 

795 ssh_pool = ssh_utils.SSHPool(instance_details['ip'], 

796 22, 

797 interval, 

798 instance_details['username'], 

799 instance_details.get('password'), 

800 instance_details.get('pk_path'), 

801 max_size=1) 

802 while time.time() - t < self.max_time_to_build_instance: 

803 LOG.debug('Checking server availability.') 

804 if not self._test_server_connection(instance_details, ssh_pool): 

805 time.sleep(interval) 

806 else: 

807 return True 

808 return False 

809 

810 def _test_server_connection(self, server, ssh_pool): 

811 conn = None 

812 try: 

813 conn = ssh_pool.create(quiet=True) 

814 return True 

815 except Exception as e: 

816 LOG.debug(e) 

817 LOG.debug("Could not login to server %s over SSH. Waiting...", 

818 server["ip"]) 

819 return False 

820 finally: 

821 if conn: 

822 conn.close() 

823 

824 def delete_service_instance(self, context, server_details): 

825 """Removes share infrastructure. 

826 

827 Deletes service vm and subnet, associated to share network. 

828 """ 

829 instance_id = server_details.get("instance_id") 

830 self._delete_server(context, instance_id) 

831 self.network_helper.teardown_network(server_details) 

832 

833 def wait_for_instance_to_be_active(self, instance_id, timeout): 

834 t = time.time() 

835 while time.time() - t < timeout: 

836 try: 

837 service_instance = self.compute_api.server_get( 

838 self.admin_context, 

839 instance_id) 

840 except exception.InstanceNotFound as e: 

841 LOG.debug(e) 

842 time.sleep(1) 

843 continue 

844 

845 instance_status = service_instance['status'] 

846 # NOTE(vponomaryov): emptiness of 'networks' field checked as 

847 # workaround for nova/neutron bug #1210483. 

848 if (instance_status == 'ACTIVE' and 

849 service_instance.get('networks', {})): 

850 return service_instance 

851 elif service_instance['status'] == 'ERROR': 

852 break