def instantiate(self, update_existing, disable_rollback=True): main_tmpl = self._get_main_template() heat = h.client() kwargs = { 'stack_name': self.cluster.stack_name, 'timeout_mins': 180, 'disable_rollback': disable_rollback, 'parameters': {}, 'template': main_tmpl, 'files': self.files} if CONF.heat_stack_tags: kwargs['tags'] = ",".join(CONF.heat_stack_tags) if not update_existing: LOG.debug("Creating Heat stack with args: {args}" .format(args=kwargs)) b.execute_with_retries(heat.stacks.create, **kwargs) else: stack = h.get_stack(self.cluster.stack_name) self.last_updated_time = stack.updated_time LOG.debug("Updating Heat stack {stack} with args: " "{args}".format(stack=stack, args=kwargs)) b.execute_with_retries(stack.update, **kwargs) self.heat_stack = h.get_stack(self.cluster.stack_name)
def get_image(**kwargs): if len(kwargs) == 1 and 'id' in kwargs: return b.execute_with_retries( sahara_images.image_manager().get, kwargs['id']) else: return b.execute_with_retries( sahara_images.image_manager().find, **kwargs)
def init_instances_ips(instance): """Extracts internal and management ips. As internal ip will be used the first ip from the nova networks CIDRs. If use_floating_ip flag is set than management ip will be the first non-internal ip. """ server = nova.get_instance_info(instance) management_ip = None internal_ip = None for network_label, addresses in six.iteritems(server.addresses): for address in addresses: if address['OS-EXT-IPS:type'] == 'fixed': internal_ip = internal_ip or address['addr'] else: management_ip = management_ip or address['addr'] cluster = instance.cluster if (not CONF.use_floating_ips or (cluster.has_proxy_gateway() and not instance.node_group.is_proxy_gateway)): management_ip = internal_ip # NOTE(aignatov): Once bug #1262529 is fixed this 'if' block should be # reviewed and reformatted again, probably removed completely. if CONF.use_neutron and not (management_ip and internal_ip): LOG.debug("Instance doesn't yet contain Floating IP or Internal IP. " "Floating IP={mgmt_ip}, Internal IP={internal_ip}. " "Trying to get via Neutron.".format( mgmt_ip=management_ip, internal_ip=internal_ip)) neutron_client = neutron.client() ports = b.execute_with_retries( neutron_client.list_ports, device_id=server.id)["ports"] if ports: target_port_id = ports[0]['id'] fl_ips = b.execute_with_retries( neutron_client.list_floatingips, port_id=target_port_id)['floatingips'] if fl_ips: fl_ip = fl_ips[0] if not internal_ip: internal_ip = fl_ip['fixed_ip_address'] LOG.debug('Found fixed IP {internal_ip}' .format(internal_ip=internal_ip)) # Zeroing management_ip if Sahara in private network if not CONF.use_floating_ips: management_ip = internal_ip elif not management_ip: management_ip = fl_ip['floating_ip_address'] LOG.debug('Found floating IP {mgmt_ip}' .format(mgmt_ip=management_ip)) conductor.instance_update(context.ctx(), instance, {"management_ip": management_ip, "internal_ip": internal_ip}) return internal_ip and management_ip
def instantiate(self, update_existing, disable_rollback=True): main_tmpl = self._get_main_template() kwargs = { 'stack_name': self.cluster.stack_name, 'timeout_mins': 180, 'disable_rollback': disable_rollback, 'parameters': {}, 'template': main_tmpl, 'files': self.files} if CONF.heat_stack_tags: kwargs['tags'] = ",".join(CONF.heat_stack_tags) log_kwargs = copy.deepcopy(kwargs) log_kwargs['template'] = yaml.safe_load(log_kwargs['template']) for filename in log_kwargs['files'].keys(): log_kwargs['files'][filename] = yaml.safe_load( log_kwargs['files'][filename]) log_kwargs = json.dumps(log_kwargs) if not update_existing: LOG.debug("Creating Heat stack with args: \n{args}" .format(args=log_kwargs)) b.execute_with_retries(h.client().stacks.create, **kwargs) else: stack = h.get_stack(self.cluster.stack_name) self.last_updated_time = stack.updated_time LOG.debug("Updating Heat stack {stack} with args: \n" "{args}".format(stack=stack, args=log_kwargs)) b.execute_with_retries(stack.update, **kwargs)
def _get_neutron_limits(): limits = {} neutron = neutron_client.client() tenant_id = context.ctx().tenant_id total_lim = b.execute_with_retries(neutron.show_quota, tenant_id)['quota'] # tmckay-fp here we would just get the limits all the time usage_fip = b.execute_with_retries( neutron.list_floatingips, tenant_id=tenant_id)['floatingips'] limits['floatingips'] = _sub_limit(total_lim['floatingip'], len(usage_fip)) usage_sg = b.execute_with_retries( neutron.list_security_groups, tenant_id=tenant_id).get( 'security_groups', []) limits['security_groups'] = _sub_limit(total_lim['security_group'], len(usage_sg)) usage_sg_rules = b.execute_with_retries( neutron.list_security_group_rules, tenant_id=tenant_id).get( 'security_group_rules', []) limits['security_group_rules'] = _sub_limit( total_lim['security_group_rule'], len(usage_sg_rules)) usage_ports = b.execute_with_retries( neutron.list_ports, tenant_id=tenant_id)['ports'] limits['ports'] = _sub_limit(total_lim['port'], len(usage_ports)) return limits
def _delete_volume(volume_id): LOG.debug("Deleting volume {volume}".format(volume=volume_id)) volume = cinder.get_volume(volume_id) try: b.execute_with_retries(volume.delete) except Exception: LOG.error("Can't delete volume {volume}".format(volume=volume.id))
def _get_neutron_limits(): limits = {} if not CONF.use_neutron: return limits neutron = neutron_client.client() tenant_id = context.ctx().tenant_id total_lim = b.execute_with_retries(neutron.show_quota, tenant_id)['quota'] if CONF.use_floating_ips: usage_fip = b.execute_with_retries( neutron.list_floatingips, tenant_id=tenant_id)['floatingips'] limits['floatingips'] = _sub_limit(total_lim['floatingip'], len(usage_fip)) usage_sg = b.execute_with_retries( neutron.list_security_groups, tenant_id=tenant_id).get( 'security_groups', []) limits['security_groups'] = _sub_limit(total_lim['security_group'], len(usage_sg)) usage_sg_rules = b.execute_with_retries( neutron.list_security_group_rules, tenant_id=tenant_id).get( 'security_group_rules', []) limits['security_group_rules'] = _sub_limit( total_lim['security_group_rule'], len(usage_sg_rules)) usage_ports = b.execute_with_retries( neutron.list_ports, tenant_id=tenant_id)['ports'] limits['ports'] = _sub_limit(total_lim['port'], len(usage_ports)) return limits
def proxy_user_delete(username=None, user_id=None): '''Delete the user from the proxy domain. :param username: The name of the user to delete. :param user_id: The id of the user to delete, if provided this overrides the username. :raises NotFoundException: If there is an error locating the user in the proxy domain. ''' admin = k.client_for_admin() if not user_id: domain = domain_for_proxy() user_list = b.execute_with_retries( admin.users.list, domain=domain.id, name=username) if len(user_list) == 0: raise ex.NotFoundException( value=username, message_template=_('Failed to find user %s')) if len(user_list) > 1: raise ex.NotFoundException( value=username, message_template=_('Unexpected results found when searching ' 'for user %s')) user_id = user_list[0].id b.execute_with_retries(admin.users.delete, user_id) LOG.debug('Deleted proxy user id {user_id}'.format(user_id=user_id))
def wait_stack_completion(stack, is_update=False, last_updated_time=None): base.execute_with_retries(stack.get) while not _verify_completion(stack, is_update, last_updated_time): context.sleep(1) base.execute_with_retries(stack.get) if stack.status != 'COMPLETE': raise ex.HeatStackException(stack.stack_status_reason)
def _delete_aa_server_group(self, cluster): if cluster.anti_affinity: server_group_name = g.generate_aa_group_name(cluster.name) client = nova.client().server_groups server_groups = b.execute_with_retries(client.findall, name=server_group_name) if len(server_groups) == 1: b.execute_with_retries(client.delete, server_groups[0].id)
def wait_stack_completion(stack): # NOTE: expected empty status because status of stack # maybe is not set in heat database while stack.status in ['IN_PROGRESS', '']: context.sleep(1) base.execute_with_retries(stack.get) if stack.status != 'COMPLETE': raise ex.HeatStackException(stack.stack_status)
def get_private_network_cidrs(cluster): neutron_client = client() private_net = base.execute_with_retries(neutron_client.show_network, cluster.neutron_management_network) cidrs = [] for subnet_id in private_net["network"]["subnets"]: subnet = base.execute_with_retries(neutron_client.show_subnet, subnet_id) cidrs.append(subnet["subnet"]["cidr"]) return cidrs
def _detach_volume(instance, volume_id): volume = cinder.get_volume(volume_id) try: LOG.debug("Detaching volume {id} from instance".format(id=volume_id)) b.execute_with_retries(nova.client().volumes.delete_server_volume, instance.instance_id, volume_id) except Exception: LOG.error(_LE("Can't detach volume {id}").format(id=volume.id)) detach_timeout = CONF.timeouts.detach_volume_timeout LOG.debug("Waiting {timeout} seconds to detach {id} volume".format(timeout=detach_timeout, id=volume_id)) _await_detach(volume_id)
def proxy_user_create(username): '''Create a new user in the proxy domain Creates the username specified with a random password. :param username: The name of the new user. :returns: The password created for the user. ''' admin = k.client_for_admin() domain = domain_for_proxy() password = six.text_type(uuid.uuid4()) b.execute_with_retries( admin.users.create, name=username, password=password, domain=domain.id) LOG.debug('Created proxy user {username}'.format(username=username)) return password
def delete_stack(cluster): stack_name = cluster.stack_name base.execute_with_retries(client().stacks.delete, stack_name) stack = get_stack(stack_name, raise_on_missing=False) while stack is not None: # Valid states: IN_PROGRESS, empty and COMPLETE if stack.status in ['IN_PROGRESS', '', 'COMPLETE']: context.sleep(5) else: raise ex.HeatStackException( message=_( "Cannot delete heat stack {name}, reason: " "stack status: {status}, status reason: {reason}").format( name=stack_name, status=stack.status, reason=stack.stack_status_reason)) stack = get_stack(stack_name, raise_on_missing=False)
def proxy_domain_users_list(): '''Return a list of all users in the proxy domain.''' admin = k.client_for_admin() domain = domain_for_proxy() if domain: return b.execute_with_retries(admin.users.list, domain=domain.id) return []
def shutdown_cluster(self, cluster): """Shutdown specified cluster and all related resources.""" try: b.execute_with_retries(heat.client().stacks.delete, cluster.name) stack = heat.get_stack(cluster.name) heat.wait_stack_completion(stack) except heat_exc.HTTPNotFound: LOG.warning(_LW('Did not find stack for cluster. Trying to delete ' 'cluster manually.')) # Stack not found. Trying to delete cluster like direct engine # do it self._shutdown_instances(cluster) self._delete_aa_server_group(cluster) self._clean_job_executions(cluster) self._remove_db_objects(cluster)
def get_stack(stack_name): heat = client() for stack in base.execute_with_retries(heat.stacks.list): if stack.stack_name == stack_name: return stack raise ex.NotFoundException(_('Failed to find stack %(stack)s') % {'stack': stack_name})
def _get_nova_limits(): limits = {} nova = nova_client.client() lim = b.execute_with_retries(nova.limits.get).to_dict()['absolute'] limits['ram'] = _sub_limit(lim['maxTotalRAMSize'], lim['totalRAMUsed']) limits['cpu'] = _sub_limit(lim['maxTotalCores'], lim['totalCoresUsed']) limits['instances'] = _sub_limit(lim['maxTotalInstances'], lim['totalInstancesUsed']) return limits
def get_stack(stack_name, raise_on_missing=True): for stack in base.execute_with_retries( client().stacks.list, filters={'name': stack_name}): return stack if not raise_on_missing: return None raise ex.NotFoundException({'stack': stack_name}, _('Failed to find stack %(stack)s'))
def instantiate(self, update_existing, disable_rollback=True): main_tmpl = self._get_main_template() heat = h.client() kwargs = { 'stack_name': self.cluster.name, 'timeout_mins': 180, 'disable_rollback': disable_rollback, 'parameters': {}, 'template': main_tmpl} if not update_existing: b.execute_with_retries(heat.stacks.create, **kwargs) else: for stack in b.execute_with_retries(heat.stacks.list): if stack.stack_name == self.cluster.name: b.execute_with_retries(stack.update, **kwargs) break return ClusterStack(self, h.get_stack(self.cluster.name))
def instantiate(self, update_existing, disable_rollback=True): files = {} main_tmpl = self._get_main_template(files) heat = h.client() kwargs = { 'stack_name': self.cluster.name, 'timeout_mins': 180, 'disable_rollback': disable_rollback, 'parameters': {}, 'template': main_tmpl, 'files': files} if not update_existing: b.execute_with_retries(heat.stacks.create, **kwargs) else: stack = h.get_stack(self.cluster.name) b.execute_with_retries(stack.update, **kwargs) self.heat_stack = h.get_stack(self.cluster.name)
def _shutdown_instance(self, instance): if instance.node_group.floating_ip_pool: try: b.execute_with_retries(networks.delete_floating_ip, instance.instance_id) except nova_exceptions.NotFound: LOG.warning(_LW("Attempted to delete non-existent floating IP " "in pool {pool} from instance") .format(pool=instance.node_group.floating_ip_pool)) try: volumes.detach_from_instance(instance) except Exception: LOG.warning(_LW("Detaching volumes from instance failed")) try: b.execute_with_retries(nova.client().servers.delete, instance.instance_id) except nova_exceptions.NotFound: LOG.warning(_LW("Attempted to delete non-existent instance")) conductor.instance_remove(context.ctx(), instance)
def _create_attach_volume(ctx, instance, size, volume_type, volume_local_to_instance, name=None, availability_zone=None): if CONF.cinder.api_version == 1: kwargs = {'size': size, 'display_name': name} else: kwargs = {'size': size, 'name': name} kwargs['volume_type'] = volume_type if availability_zone is not None: kwargs['availability_zone'] = availability_zone if volume_local_to_instance: kwargs['scheduler_hints'] = {'local_to_instance': instance.instance_id} volume = b.execute_with_retries(cinder.client().volumes.create, **kwargs) conductor.append_volume(ctx, instance, volume.id) _await_available(volume) resp = b.execute_with_retries(nova.client().volumes.create_server_volume, instance.instance_id, volume.id, None) return resp.device
def _get_cinder_limits(): avail_limits = {} cinder = cinder_client.client() lim = {} for l in b.execute_with_retries(cinder.limits.get).absolute: lim[l.name] = l.value avail_limits['volumes'] = _sub_limit(lim['maxTotalVolumes'], lim['totalVolumesUsed']) avail_limits['volume_gbs'] = _sub_limit(lim['maxTotalVolumeGigabytes'], lim['totalGigabytesUsed']) return avail_limits
def _delete_auto_security_group(self, node_group): if not node_group.auto_security_group: return if not node_group.security_groups: # node group has no security groups # nothing to delete return name = node_group.security_groups[-1] try: client = nova.client().security_groups security_group = b.execute_with_retries(client.get, name) if (security_group.name != g.generate_auto_security_group_name(node_group)): LOG.warning(_LW("Auto security group for node group {name} is " "not found").format(name=node_group.name)) return b.execute_with_retries(client.delete, name) except Exception: LOG.warning(_LW("Failed to delete security group {name}").format( name=name))
def retrieve_preauth_url(): '''This function returns the storage URL for Swift in the current project. :returns: The storage URL for the current project's Swift store, or None if it can't be found. ''' client = k.client() catalog = clients_base.execute_with_retries( client.service_catalog.get_endpoints, 'object-store') for ep in catalog.get('object-store'): if ep.get('interface') == 'public': return ep.get('url') return None
def _get_nova_limits(): limits = {} nova = nova_client.client() lim = b.execute_with_retries(nova.limits.get).to_dict()['absolute'] limits['ram'] = _sub_limit(lim['maxTotalRAMSize'], lim['totalRAMUsed']) limits['cpu'] = _sub_limit(lim['maxTotalCores'], lim['totalCoresUsed']) limits['instances'] = _sub_limit(lim['maxTotalInstances'], lim['totalInstancesUsed']) if CONF.use_neutron: return limits if CONF.use_floating_ips: limits['floatingips'] = _sub_limit(lim['maxTotalFloatingIps'], lim['totalFloatingIpsUsed']) limits['security_groups'] = _sub_limit(lim['maxSecurityGroups'], lim['totalSecurityGroupsUsed']) limits['security_group_rules'] = _sub_limit(lim['maxSecurityGroupRules'], 0) return limits
def _update_limits_for_ng(limits, ng, count): sign = lambda x: (1, -1)[x < 0] nova = nova_client.client() limits['instances'] += count flavor = b.execute_with_retries(nova.flavors.get, ng.flavor_id) limits['ram'] += flavor.ram * count limits['cpu'] += flavor.vcpus * count # tmckay-fp this is fine, it will be zero without it if ng.floating_ip_pool: limits['floatingips'] += count if ng.volumes_per_node: limits['volumes'] += ng.volumes_per_node * count limits['volume_gbs'] += ng.volumes_per_node * ng.volumes_size * count if ng.auto_security_group: limits['security_groups'] += sign(count) # NOTE: +3 - all traffic for private network limits['security_group_rules'] += ( (len(ng.open_ports) + 3) * sign(count)) limits['ports'] += count
def get_router(self): matching_router = NeutronClient.routers.get(self.network, None) if matching_router: LOG.debug("Returning cached qrouter") return matching_router["id"] routers = self.neutron.list_routers()["routers"] for router in routers: device_id = router["id"] ports = base.execute_with_retries(self.neutron.list_ports, device_id=device_id)["ports"] port = next((port for port in ports if port["network_id"] == self.network), None) if port: matching_router = router NeutronClient.routers[self.network] = matching_router break if not matching_router: raise ex.SystemError(_("Neutron router corresponding to network " "%s is not found") % self.network) return matching_router["id"]
def domain_for_proxy(): '''Return the proxy domain or None If configured to use the proxy domain, this function will return that domain. If not configured to use the proxy domain, this function will return None. If the proxy domain can't be found this will raise an exception. :returns: A Keystone Domain object or None. :raises ConfigurationError: If the domain is requested but not specified. :raises NotFoundException: If the domain name is specified but cannot be found. ''' if CONF.use_domain_for_proxy_users is False: return None if CONF.proxy_user_domain_name is None: raise ex.ConfigurationError( _('Proxy domain requested but not ' 'specified.')) admin = k.client_for_admin() global PROXY_DOMAIN if not PROXY_DOMAIN: domain_list = b.execute_with_retries(admin.domains.list, name=CONF.proxy_user_domain_name) if len(domain_list) == 0: raise ex.NotFoundException( value=CONF.proxy_user_domain_name, message_template=_('Failed to find domain %s')) # the domain name should be globally unique in Keystone if len(domain_list) > 1: raise ex.NotFoundException( value=CONF.proxy_user_domain_name, message_template=_('Unexpected results found when searching ' 'for domain %s')) PROXY_DOMAIN = domain_list[0] return PROXY_DOMAIN
def generate_topology_map(cluster, is_node_awareness): mapping = _read_compute_topology() nova_client = nova.client() topology_mapping = {} for ng in cluster.node_groups: for i in ng.instances: # TODO(alazarev) get all servers info with one request ni = b.execute_with_retries(nova_client.servers.get, i.instance_id) hostId = ni.hostId if hostId not in mapping: raise ex.NotFoundException( i.instance_id, _("Was not able to find compute node topology for VM %s")) rack = mapping[hostId] if is_node_awareness: rack += "/" + hostId topology_mapping[i.instance_name] = rack topology_mapping[i.management_ip] = rack topology_mapping[i.internal_ip] = rack topology_mapping.update(_read_swift_topology()) return topology_mapping
def _update_limits_for_ng(limits, ng, count): sign = lambda x: (1, -1)[x < 0] nova = nova_client.client() limits['instances'] += count flavor = b.execute_with_retries(nova.flavors.get, ng.flavor_id) limits['ram'] += flavor.ram * count limits['cpu'] += flavor.vcpus * count # tmckay-fp this is fine, it will be zero without it if ng.floating_ip_pool: limits['floatingips'] += count if ng.volumes_per_node: limits['volumes'] += ng.volumes_per_node * count limits['volume_gbs'] += ng.volumes_per_node * ng.volumes_size * count if ng.auto_security_group: limits['security_groups'] += sign(count) # NOTE: +3 - all traffic for private network if CONF.use_neutron: limits['security_group_rules'] += ( (len(ng.open_ports) + 3) * sign(count)) else: limits['security_group_rules'] = max( limits['security_group_rules'], len(ng.open_ports) + 3) if CONF.use_neutron: limits['ports'] += count
def _delete_aa_server_groups(self, cluster): if cluster.anti_affinity: for i in range(1, cluster.anti_affinity_ratio): server_group_name = g.generate_aa_group_name(cluster.name, i) client = nova.client().server_groups server_groups = b.execute_with_retries(client.findall, name=server_group_name) if len(server_groups) == 1: b.execute_with_retries(client.delete, server_groups[0].id) '''In case the server group is created using mitaka or older version''' old_server_group_name = server_group_name.rsplit('-', 1)[0] server_groups_old = b.execute_with_retries( client.findall, name=old_server_group_name) if len(server_groups_old) == 1: b.execute_with_retries(client.delete, server_groups_old[0].id)
def remove_image_tags(image_id, tags): manager = sahara_images.image_manager() b.execute_with_retries(manager.untag, image_id, tags) return b.execute_with_retries(manager.get, image_id)
def register_image(image_id, username, description=None): manager = sahara_images.image_manager() b.execute_with_retries( manager.set_image_info, image_id, username, description) return b.execute_with_retries(manager.get, image_id)
def unregister_image(image_id): manager = sahara_images.image_manager() b.execute_with_retries(manager.unset_image_info, image_id) return b.execute_with_retries(manager.get, image_id)
def get_node_group_image_username(self, node_group): image_id = node_group.get_image_id() return b.execute_with_retries( nova.client().images.get, image_id).username
def assign_floating_ip(instance_id, pool): ip = b.execute_with_retries(nova.client().floating_ips.create, pool) server = b.execute_with_retries(nova.client().servers.get, instance_id) b.execute_with_retries(server.add_floating_ip, ip)
def unregister_image(image_id): client = nova.client() b.execute_with_retries(client.images.unset_description, image_id) return b.execute_with_retries(client.images.get, image_id)
def get_keypair(keypair_name): return base.execute_with_retries(client().keypairs.get, keypair_name)
def get_images(name, tags): return b.execute_with_retries( nova.client().images.list_registered, name, tags)
def get_registered_image(id): return b.execute_with_retries( nova.client().images.get_registered_image, id)
def lazy_delete_stack(cluster): '''Attempt to delete stack once, but do not await successful deletion''' stack_name = cluster.stack_name base.execute_with_retries(client().stacks.delete, stack_name)
def init_instances_ips(instance): """Extracts internal and management ips. As internal ip will be used the first ip from the nova networks CIDRs. If use_floating_ip flag is set than management ip will be the first non-internal ip. """ server = nova.get_instance_info(instance) management_ip = None internal_ip = None for addresses in six.itervalues(server.addresses): # selects IPv4 preferentially for address in sorted(addresses, key=lambda addr: addr['version']): if address['OS-EXT-IPS:type'] == 'fixed': internal_ip = internal_ip or address['addr'] else: management_ip = management_ip or address['addr'] cluster = instance.cluster if (not CONF.use_floating_ips or (cluster.has_proxy_gateway() and not instance.node_group.is_proxy_gateway)): management_ip = internal_ip # NOTE(aignatov): Once bug #1262529 is fixed this 'if' block should be # reviewed and reformatted again, probably removed completely. if CONF.use_neutron and not (management_ip and internal_ip): LOG.debug("Instance doesn't yet contain Floating IP or Internal IP. " "Floating IP={mgmt_ip}, Internal IP={internal_ip}. " "Trying to get via Neutron.".format(mgmt_ip=management_ip, internal_ip=internal_ip)) neutron_client = neutron.client() ports = b.execute_with_retries(neutron_client.list_ports, device_id=server.id)["ports"] if ports: target_port_id = ports[0]['id'] fl_ips = b.execute_with_retries( neutron_client.list_floatingips, port_id=target_port_id)['floatingips'] if fl_ips: fl_ip = fl_ips[0] if not internal_ip: internal_ip = fl_ip['fixed_ip_address'] LOG.debug('Found fixed IP {internal_ip}'.format( internal_ip=internal_ip)) # Zeroing management_ip if Sahara in private network if not CONF.use_floating_ips: management_ip = internal_ip elif not management_ip: management_ip = fl_ip['floating_ip_address'] LOG.debug('Found floating IP {mgmt_ip}'.format( mgmt_ip=management_ip)) conductor.instance_update(context.ctx(), instance, { "management_ip": management_ip, "internal_ip": internal_ip }) return internal_ip and management_ip
def _find_instance_volume_devices(instance): volumes = b.execute_with_retries(nova.client().volumes.get_server_volumes, instance.instance_id) devices = [volume.device for volume in volumes] return devices
def get_image_tags(image_id): return b.execute_with_retries(sahara_images.image_manager().get, image_id).tags
def delete_floating_ip(instance_id): fl_ips = b.execute_with_retries(nova.client().floating_ips.findall, instance_id=instance_id) for fl_ip in fl_ips: b.execute_with_retries(nova.client().floating_ips.delete, fl_ip.id)
def get_image(**kwargs): if len(kwargs) == 1 and 'id' in kwargs: return b.execute_with_retries(nova.client().images.get, kwargs['id']) else: return b.execute_with_retries(nova.client().images.find, **kwargs)
def get_node_group_image_username(self, node_group): image_id = node_group.get_image_id() return b.execute_with_retries(sahara_images.image_manager().get, image_id).username
def register_image(image_id, username, description=None): client = nova.client() b.execute_with_retries( client.images.set_description, image_id, username, description) return b.execute_with_retries(client.images.get, image_id)
def get_images(name, tags): return b.execute_with_retries( sahara_images.image_manager().list_registered, name, tags)
def remove_image_tags(image_id, tags): client = nova.client() b.execute_with_retries(client.images.untag, image_id, tags) return b.execute_with_retries(client.images.get, image_id)
def get_resource(stack, resource): return base.execute_with_retries(client().resources.get, stack, resource)
def get_volume(volume_id): return base.execute_with_retries(client().volumes.get, volume_id)
def get_registered_image(id): return b.execute_with_retries( sahara_images.image_manager().get_registered_image, id)
def get_flavor(**kwargs): return base.execute_with_retries(client().flavors.find, **kwargs)
def get_instance_info(instance): return base.execute_with_retries(client().servers.get, instance.instance_id)
def get_network(**kwargs): try: return base.execute_with_retries(client().networks.find, **kwargs) except nova_ex.NotFound: return None
def get_network(id): try: return base.execute_with_retries(client().find_resource_by_id, 'network', id) except n_ex.NotFound: return None