def create(self, req, body): """Instruct Cinder to manage a storage object. Manages an existing backend storage object (e.g. a Linux logical volume or a SAN disk) by creating the Cinder objects required to manage it, and possibly renaming the backend storage object (driver dependent) From an API perspective, this operation behaves very much like a volume creation operation, except that properties such as image, snapshot and volume references don't make sense, because we are taking an existing storage object into Cinder management. Required HTTP Body: { 'volume': { 'host': <Cinder host on which the existing storage resides>, 'ref': <Driver-specific reference to the existing storage object>, } } See the appropriate Cinder drivers' implementations of the manage_volume method to find out the accepted format of 'ref'. This API call will return with an error if any of the above elements are missing from the request, or if the 'host' element refers to a cinder host that is not registered. The volume will later enter the error state if it is discovered that 'ref' is bad. Optional elements to 'volume' are: name A name for the new volume. description A description for the new volume. volume_type ID or name of a volume type to associate with the new Cinder volume. Does not necessarily guarantee that the managed volume will have the properties described in the volume_type. The driver may choose to fail if it identifies that the specified volume_type is not compatible with the backend storage object. metadata Key/value pairs to be associated with the new volume. availability_zone The availability zone to associate with the new volume. """ context = req.environ['cinder.context'] authorize(context) if not self.is_valid_body(body, 'volume'): msg = _("Missing required element '%s' in request body") % 'volume' raise exc.HTTPBadRequest(explanation=msg) volume = body['volume'] # Check that the required keys are present, return an error if they # are not. required_keys = set(['ref', 'host']) missing_keys = list(required_keys - set(volume.keys())) if missing_keys: msg = _("The following elements are required: %s") % \ ', '.join(missing_keys) raise exc.HTTPBadRequest(explanation=msg) LOG.debug('Manage volume request body: %s', body) kwargs = {} req_volume_type = volume.get('volume_type', None) if req_volume_type: try: if not uuidutils.is_uuid_like(req_volume_type): kwargs['volume_type'] = \ volume_types.get_volume_type_by_name( context, req_volume_type) else: kwargs['volume_type'] = volume_types.get_volume_type( context, req_volume_type) except exception.VolumeTypeNotFound: msg = _("Volume type not found.") raise exc.HTTPNotFound(explanation=msg) else: kwargs['volume_type'] = {} kwargs['name'] = volume.get('name', None) kwargs['description'] = volume.get('description', None) kwargs['metadata'] = volume.get('metadata', None) kwargs['availability_zone'] = volume.get('availability_zone', None) try: new_volume = self.volume_api.manage_existing( context, volume['host'], volume['ref'], **kwargs) except exception.ServiceNotFound: msg = _("Service not found.") raise exc.HTTPNotFound(explanation=msg) new_volume = dict(new_volume.iteritems()) utils.add_visible_admin_metadata(context, new_volume, self.volume_api) return self._view_builder.detail(req, new_volume)
def nbhd_lookup_first_path(nbhd, name, current_user, remainder, api=False): """ Resolve first part of a neighborhood url. May raise 404, redirect, or do other side effects. Shared between NeighborhoodController and NeighborhoodRestController :param nbhd: neighborhood :param name: project or tool name (next part of url) :param current_user: a User :param remainder: remainder of url :param bool api: whether this is handling a /rest/ request or not :return: project (to be set as c.project) :return: remainder (possibly modified) """ prefix = nbhd.shortname_prefix pname = unquote(name) pname = six.ensure_text( pname ) # we don't support unicode names, but in case a url comes in with one try: pname.encode('ascii') except UnicodeError: raise exc.HTTPNotFound provider = plugin.ProjectRegistrationProvider.get() try: provider.shortname_validator.to_python(pname, check_allowed=False, neighborhood=nbhd) except Invalid: project = None else: project = M.Project.query.get(shortname=prefix + pname, neighborhood_id=nbhd._id) if project is None and prefix == 'u/': # create user-project if it is missing user = M.User.query.get(username=pname, disabled=False, pending=False) if user: project = user.private_project() if project is None: # look for neighborhood tools matching the URL project = nbhd.neighborhood_project return project, ( pname, ) + remainder # include pname in new remainder, it is actually the nbhd tool path if project and prefix == 'u/': # make sure user-projects are associated with an enabled user user = project.user_project_of if not user or user.disabled or user.pending: raise exc.HTTPNotFound if not api and user.url() != '/{}{}/'.format(prefix, pname): # might be different URL than the URL requested # e.g. if username isn't valid project name and user_project_shortname() converts the name new_url = user.url() new_url += '/'.join(remainder) if request.query_string: new_url += '?' + request.query_string redirect(new_url) if project.database_configured is False: if remainder == ('user_icon', ): redirect(g.forge_static('images/user.png')) elif current_user.username == pname: log.info('Configuring %s database for access to %r', pname, remainder) project.configure_project(is_user_project=True) else: raise exc.HTTPNotFound(pname) if project is None or (project.deleted and not has_access(project, 'update')()): raise exc.HTTPNotFound(pname) return project, remainder
def default(self, req, **args): raise exc.HTTPNotFound()
def create(self, req, body): context = req.environ['nova.context'] authorize(context) if not body: raise exc.HTTPUnprocessableEntity() if not 'security_group_rule' in body: raise exc.HTTPUnprocessableEntity() self.compute_api.ensure_default_security_group(context) sg_rule = body['security_group_rule'] parent_group_id = sg_rule.get('parent_group_id', None) try: parent_group_id = int(parent_group_id) security_group = db.security_group_get(context, parent_group_id) except ValueError: msg = _("Parent group id is not integer") raise exc.HTTPBadRequest(explanation=msg) except exception.NotFound as exp: msg = _("Security group (%s) not found") % parent_group_id raise exc.HTTPNotFound(explanation=msg) msg = _("Authorize security group ingress %s") LOG.audit(msg, security_group['name'], context=context) try: values = self._rule_args_to_dict(context, to_port=sg_rule.get('to_port'), from_port=sg_rule.get('from_port'), parent_group_id=sg_rule.get('parent_group_id'), ip_protocol=sg_rule.get('ip_protocol'), cidr=sg_rule.get('cidr'), group_id=sg_rule.get('group_id')) except Exception as exp: raise exc.HTTPBadRequest(explanation=unicode(exp)) if values is None: msg = _("Not enough parameters to build a " "valid rule.") raise exc.HTTPBadRequest(explanation=msg) values['parent_group_id'] = security_group.id if self._security_group_rule_exists(security_group, values): msg = _('This rule already exists in group %s') % parent_group_id raise exc.HTTPBadRequest(explanation=msg) allowed = quota.allowed_security_group_rules(context, parent_group_id, 1) if allowed < 1: msg = _("Quota exceeded, too many security group rules.") raise exc.HTTPBadRequest(explanation=msg) security_group_rule = db.security_group_rule_create(context, values) self.sgh.trigger_security_group_rule_create_refresh( context, [security_group_rule['id']]) self.compute_api.trigger_security_group_rules_refresh(context, security_group_id=security_group['id']) return {"security_group_rule": self._format_security_group_rule( context, security_group_rule)}
def create(self, req, body): """Creates a new volume.""" if not self.is_valid_body(body, 'volume'): msg = _("Missing required element '%s' in request body") % 'volume' raise exc.HTTPBadRequest(explanation=msg) LOG.debug('Create volume request body: %s', body) context = req.environ['cinder.context'] volume = body['volume'] kwargs = {} # NOTE(thingee): v2 API allows name instead of display_name if volume.get('name'): volume['display_name'] = volume.get('name') del volume['name'] # NOTE(thingee): v2 API allows description instead of # display_description if volume.get('description'): volume['display_description'] = volume.get('description') del volume['description'] if 'image_id' in volume: volume['imageRef'] = volume.get('image_id') del volume['image_id'] req_volume_type = volume.get('volume_type', None) if req_volume_type: try: if not uuidutils.is_uuid_like(req_volume_type): kwargs['volume_type'] = \ volume_types.get_volume_type_by_name( context, req_volume_type) else: kwargs['volume_type'] = volume_types.get_volume_type( context, req_volume_type) except exception.VolumeTypeNotFound: msg = _("Volume type not found.") raise exc.HTTPNotFound(explanation=msg) kwargs['metadata'] = volume.get('metadata', None) snapshot_id = volume.get('snapshot_id') if snapshot_id is not None: try: kwargs['snapshot'] = self.volume_api.get_snapshot( context, snapshot_id) except exception.NotFound: explanation = _('snapshot id:%s not found') % snapshot_id raise exc.HTTPNotFound(explanation=explanation) else: kwargs['snapshot'] = None source_volid = volume.get('source_volid') if source_volid is not None: try: kwargs['source_volume'] = \ self.volume_api.get_volume(context, source_volid) except exception.NotFound: explanation = _('source volume id:%s not found') % source_volid raise exc.HTTPNotFound(explanation=explanation) else: kwargs['source_volume'] = None source_replica = volume.get('source_replica') if source_replica is not None: try: src_vol = self.volume_api.get_volume(context, source_replica) if src_vol['replication_status'] == 'disabled': explanation = _('source volume id:%s is not' ' replicated') % source_volid raise exc.HTTPNotFound(explanation=explanation) kwargs['source_replica'] = src_vol except exception.NotFound: explanation = (_('replica source volume id:%s not found') % source_replica) raise exc.HTTPNotFound(explanation=explanation) else: kwargs['source_replica'] = None consistencygroup_id = volume.get('consistencygroup_id') if consistencygroup_id is not None: try: kwargs['consistencygroup'] = \ self.consistencygroup_api.get(context, consistencygroup_id) except exception.NotFound: explanation = _('Consistency group id:%s not found') % \ consistencygroup_id raise exc.HTTPNotFound(explanation=explanation) else: kwargs['consistencygroup'] = None size = volume.get('size', None) if size is None and kwargs['snapshot'] is not None: size = kwargs['snapshot']['volume_size'] elif size is None and kwargs['source_volume'] is not None: size = kwargs['source_volume']['size'] elif size is None and kwargs['source_replica'] is not None: size = kwargs['source_replica']['size'] LOG.info(_LI("Create volume of %s GB"), size, context=context) if self.ext_mgr.is_loaded('os-image-create'): image_ref = volume.get('imageRef') if image_ref is not None: image_uuid = self._image_uuid_from_ref(image_ref, context) kwargs['image_id'] = image_uuid kwargs['availability_zone'] = volume.get('availability_zone', None) kwargs['scheduler_hints'] = volume.get('scheduler_hints', None) new_volume = self.volume_api.create(context, size, volume.get('display_name'), volume.get('display_description'), **kwargs) # TODO(vish): Instance should be None at db layer instead of # trying to lazy load, but for now we turn it into # a dict to avoid an error. new_volume = dict(new_volume.iteritems()) retval = self._view_builder.detail(req, new_volume) return retval
def get_flavor(context, flavor_id): try: return objects.Flavor.get_by_flavor_id(context, flavor_id) except exception.FlavorNotFound as error: raise exc.HTTPNotFound(explanation=error.format_message())
def _verify_share(self, context, share_id): try: db_api.share_get(context, share_id) except exception.NotFound: msg = _("Share '%s' not found.") % share_id raise exc.HTTPNotFound(explanation=msg)
def update(self, req, id, body): """Update specified share network.""" context = req.environ['manila.context'] policy.check_policy(context, RESOURCE_NAME, 'update') if not body or RESOURCE_NAME not in body: raise exc.HTTPUnprocessableEntity() try: share_network = db_api.share_network_get(context, id) except exception.ShareNetworkNotFound as e: raise exc.HTTPNotFound(explanation=e.msg) update_values = body[RESOURCE_NAME] if 'nova_net_id' in update_values: msg = _("nova networking is not supported starting in Ocata.") raise exc.HTTPBadRequest(explanation=msg) if self._share_network_subnets_contain_share_servers(share_network): for value in update_values: if value not in ['name', 'description']: msg = (_("Cannot update share network %s. It is used by " "share servers. Only 'name' and 'description' " "fields are available for update") % share_network['id']) raise exc.HTTPForbidden(explanation=msg) try: if ('neutron_net_id' in update_values or 'neutron_subnet_id' in update_values): subnet = db_api.share_network_subnet_get_default_subnet( context, id) if not subnet: msg = _("The share network %(id)s does not have a " "'default' subnet that serves all availability " "zones, so subnet details " "('neutron_net_id', 'neutron_subnet_id') cannot " "be updated.") % {'id': id} raise exc.HTTPBadRequest(explanation=msg) # NOTE(silvacarlose): If the default share network subnet have # the fields neutron_net_id and neutron_subnet_id set as None, # we need to make sure that in the update request the user is # passing both parameter since a share network subnet must # have both fields filled or empty. subnet_neutron_net_and_subnet_id_are_empty = ( subnet['neutron_net_id'] is None and subnet['neutron_subnet_id'] is None) update_values_without_neutron_net_or_subnet = ( update_values.get('neutron_net_id') is None or update_values.get('neutron_subnet_id') is None) if (subnet_neutron_net_and_subnet_id_are_empty and update_values_without_neutron_net_or_subnet): msg = _( "To update the share network %(id)s you need to " "specify both 'neutron_net_id' and " "'neutron_subnet_id'.") % {'id': id} raise webob.exc.HTTPBadRequest(explanation=msg) db_api.share_network_subnet_update(context, subnet['id'], update_values) share_network = db_api.share_network_update(context, id, update_values) except db_exception.DBError: msg = "Could not save supplied data due to database error" raise exc.HTTPBadRequest(explanation=msg) return self._view_builder.build_share_network(req, share_network)
def delete(self, req, id): """Delete specified share network.""" context = req.environ['manila.context'] policy.check_policy(context, RESOURCE_NAME, 'delete') try: share_network = db_api.share_network_get(context, id) except exception.ShareNetworkNotFound as e: raise exc.HTTPNotFound(explanation=e.msg) share_instances = ( db_api.share_instances_get_all_by_share_network(context, id) ) if share_instances: msg = _("Can not delete share network %(id)s, it has " "%(len)s share(s).") % {'id': id, 'len': len(share_instances)} LOG.error(msg) raise exc.HTTPConflict(explanation=msg) # NOTE(ameade): Do not allow deletion of share network used by share # group sg_count = db_api.count_share_groups_in_share_network(context, id) if sg_count: msg = _("Can not delete share network %(id)s, it has %(len)s " "share group(s).") % {'id': id, 'len': sg_count} LOG.error(msg) raise exc.HTTPConflict(explanation=msg) # NOTE(silvacarlose): Do not allow the deletion of share networks # if it still contains two or more subnets if self._share_network_contains_subnets(share_network): msg = _("The share network %(id)s has more than one subnet " "attached. Please remove the subnets untill you have one " "or no subnets remaining.") % {'id': id} LOG.error(msg) raise exc.HTTPConflict(explanation=msg) for subnet in share_network['share_network_subnets']: if not self._all_share_servers_are_auto_deletable(subnet): msg = _("The service cannot determine if there are any " "non-managed shares on the share network subnet " "%(id)s, so it cannot be deleted. Please contact the " "cloud administrator to rectify.") % { 'id': subnet['id']} LOG.error(msg) raise exc.HTTPConflict(explanation=msg) for subnet in share_network['share_network_subnets']: for share_server in subnet['share_servers']: self.share_rpcapi.delete_share_server(context, share_server) db_api.share_network_delete(context, id) try: reservations = QUOTAS.reserve( context, project_id=share_network['project_id'], share_networks=-1, user_id=share_network['user_id']) except Exception: LOG.exception("Failed to update usages deleting " "share-network.") else: QUOTAS.commit(context, reservations, project_id=share_network['project_id'], user_id=share_network['user_id']) return webob.Response(status_int=http_client.ACCEPTED)
def _lookup(self, id=None, *remainder): if id: id = unquote(id) return self.ThreadController(self._discussion_controller, id), remainder else: raise exc.HTTPNotFound()
def __init__(self, prefix='', key='dream.app'): decoroute.App.__init__(self, prefix, key) self.map = dict(((method, decoroute.UrlMap()) for method in ('HEAD', 'GET', 'POST', 'PUT', 'DELETE'))) self.not_found(lambda e: exc.HTTPNotFound(detail='Not found')) self._render = self._render_response
def _lookup(self, name, *remainder): app = c.project.app_instance(name) if app is None: raise exc.HTTPNotFound(name) return app.admin, remainder
def create(self, req, body): """Instruct Cinder to manage a storage snapshot object. Manages an existing backend storage snapshot object (e.g. a Linux logical volume or a SAN disk) by creating the Cinder objects required to manage it, and possibly renaming the backend storage snapshot object (driver dependent). From an API perspective, this operation behaves very much like a snapshot creation operation. Required HTTP Body: .. code-block:: json { "snapshot": { "volume_id": <Cinder volume already exists in volume backend>, "ref": <Driver-specific reference to the existing storage object> } } See the appropriate Cinder drivers' implementations of the manage_snapshot method to find out the accepted format of 'ref'. For example,in LVM driver, it will be the logic volume name of snapshot which you want to manage. This API call will return with an error if any of the above elements are missing from the request, or if the 'volume_id' element refers to a cinder volume that could not be found. The snapshot will later enter the error state if it is discovered that 'ref' is bad. Optional elements to 'snapshot' are:: name A name for the new snapshot. description A description for the new snapshot. metadata Key/value pairs to be associated with the new snapshot. """ context = req.environ['cinder.context'] authorize_manage(context) if not self.is_valid_body(body, 'snapshot'): msg = _("Missing required element snapshot in request body.") raise exc.HTTPBadRequest(explanation=msg) snapshot = body['snapshot'] # Check that the required keys are present, return an error if they # are not. required_keys = ('ref', 'volume_id') missing_keys = set(required_keys) - set(snapshot.keys()) if missing_keys: msg = _("The following elements are required: " "%s") % ', '.join(missing_keys) raise exc.HTTPBadRequest(explanation=msg) # Check whether volume exists volume_id = snapshot['volume_id'] try: volume = self.volume_api.get(context, volume_id) except exception.VolumeNotFound: msg = _("Volume: %s could not be found.") % volume_id raise exc.HTTPNotFound(explanation=msg) LOG.debug('Manage snapshot request body: %s', body) snapshot_parameters = {} snapshot_parameters['metadata'] = snapshot.get('metadata', None) snapshot_parameters['description'] = snapshot.get('description', None) # NOTE(wanghao) if name in request body, we are overriding the 'name' snapshot_parameters['name'] = snapshot.get( 'name', snapshot.get('display_name')) try: new_snapshot = self.volume_api.manage_existing_snapshot( context, snapshot['ref'], volume, **snapshot_parameters) except exception.ServiceNotFound: msg = _("Service %s not found.") % CONF.volume_topic raise exc.HTTPNotFound(explanation=msg) return self._view_builder.detail(req, new_snapshot)
def _get_instance(self, context, instance_id): try: return self.compute_api.get(context, instance_id) except exception.InstanceNotFound: msg = _("Server not found") raise exc.HTTPNotFound(msg)
def create(self, req, body): """Creates a new volume.""" if not self.is_valid_body(body, 'volume'): raise exc.HTTPUnprocessableEntity() LOG.debug('Create volume request body: %s', body) context = req.environ['cinder.context'] volume = body['volume'] kwargs = {} req_volume_type = volume.get('volume_type', None) if req_volume_type: try: if not uuidutils.is_uuid_like(req_volume_type): kwargs['volume_type'] = \ volume_types.get_volume_type_by_name( context, req_volume_type) else: kwargs['volume_type'] = volume_types.get_volume_type( context, req_volume_type) except exception.VolumeTypeNotFound: explanation = 'Volume type not found.' raise exc.HTTPNotFound(explanation=explanation) kwargs['metadata'] = volume.get('metadata', None) snapshot_id = volume.get('snapshot_id') if snapshot_id is not None: try: kwargs['snapshot'] = self.volume_api.get_snapshot( context, snapshot_id) except exception.NotFound: explanation = _('snapshot id:%s not found') % snapshot_id raise exc.HTTPNotFound(explanation=explanation) else: kwargs['snapshot'] = None source_volid = volume.get('source_volid') if source_volid is not None: try: kwargs['source_volume'] = \ self.volume_api.get_volume(context, source_volid) except exception.NotFound: explanation = _('source vol id:%s not found') % source_volid raise exc.HTTPNotFound(explanation=explanation) else: kwargs['source_volume'] = None size = volume.get('size', None) if size is None and kwargs['snapshot'] is not None: size = kwargs['snapshot']['volume_size'] elif size is None and kwargs['source_volume'] is not None: size = kwargs['source_volume']['size'] LOG.info(_LI("Create volume of %s GB"), size, context=context) image_href = None image_uuid = None if self.ext_mgr.is_loaded('os-image-create'): # NOTE(jdg): misleading name "imageRef" as it's an image-id image_href = volume.get('imageRef') if image_href is not None: image_uuid = self._image_uuid_from_href(image_href) kwargs['image_id'] = image_uuid kwargs['availability_zone'] = volume.get('availability_zone', None) new_volume = self.volume_api.create(context, size, volume.get('display_name'), volume.get('display_description'), **kwargs) # TODO(vish): Instance should be None at db layer instead of # trying to lazy load, but for now we turn it into # a dict to avoid an error. new_volume = dict(new_volume.iteritems()) retval = _translate_volume_detail_view(context, new_volume, image_uuid) return {'volume': retval}
def index(self, req, server_id): try: instance = self.compute_api.get(req.environ['nova.context'], id) except nova.exception.NotFound: return faults.Fault(exc.HTTPNotFound()) return {'addresses': self.builder.build(instance)}
def _create_backup(self, req, id, body): """Backup a server instance. Images now have an `image_type` associated with them, which can be 'snapshot' or the backup type, like 'daily' or 'weekly'. If the image_type is backup-like, then the rotation factor can be included and that will cause the oldest backups that exceed the rotation factor to be deleted. """ context = req.environ["nova.context"] authorize(context, 'create_backup') try: entity = body["create_backup"] except (KeyError, TypeError): raise exc.HTTPBadRequest(_("Malformed request body")) try: image_name = entity["name"] backup_type = entity["backup_type"] rotation = entity["rotation"] except KeyError as missing_key: msg = _("create_backup entity requires %s attribute") % missing_key raise exc.HTTPBadRequest(explanation=msg) except TypeError: msg = _("Malformed create_backup entity") raise exc.HTTPBadRequest(explanation=msg) try: rotation = int(rotation) except ValueError: msg = _("create_backup attribute 'rotation' must be an integer") raise exc.HTTPBadRequest(explanation=msg) if rotation < 0: msg = _("create_backup attribute 'rotation' must be greater " "than or equal to zero") raise exc.HTTPBadRequest(explanation=msg) props = {} metadata = entity.get('metadata', {}) common.check_img_metadata_properties_quota(context, metadata) try: props.update(metadata) except ValueError: msg = _("Invalid metadata") raise exc.HTTPBadRequest(explanation=msg) try: instance = self.compute_api.get(context, id, want_objects=True) except exception.InstanceNotFound as e: raise exc.HTTPNotFound(explanation=e.format_message()) try: image = self.compute_api.backup(context, instance, image_name, backup_type, rotation, extra_properties=props) except exception.InstanceInvalidState as state_error: common.raise_http_conflict_for_instance_invalid_state( state_error, 'create_backup') resp = webob.Response(status_int=202) # build location of newly-created image entity if rotation is not zero if rotation > 0: image_id = str(image['id']) image_ref = os.path.join(req.application_url, 'images', image_id) resp.headers['Location'] = image_ref return resp
def private(self, req, server_id): try: instance = self.compute_api.get(req.environ['nova.context'], id) except nova.exception.NotFound: return faults.Fault(exc.HTTPNotFound()) return {'private': self.builder.build_private_parts(instance)}
def _action_rebuild(self, req, id, body): """Rebuild an instance with the given attributes.""" rebuild_dict = body['rebuild'] image_href = rebuild_dict["imageRef"] image_href = self._image_uuid_from_href(image_href) password = self._get_server_admin_password(rebuild_dict) context = req.environ['nova.context'] authorize(context, action='rebuild') instance = self._get_server(context, req, id) attr_map = { 'name': 'display_name', 'metadata': 'metadata', } rebuild_kwargs = {} if list(self.rebuild_extension_manager): self.rebuild_extension_manager.map(self._rebuild_extension_point, rebuild_dict, rebuild_kwargs) for request_attribute, instance_attribute in attr_map.items(): try: rebuild_kwargs[instance_attribute] = rebuild_dict[ request_attribute] except (KeyError, TypeError): pass try: self.compute_api.rebuild(context, instance, image_href, password, **rebuild_kwargs) except exception.InstanceIsLocked as e: raise exc.HTTPConflict(explanation=e.format_message()) except exception.InstanceInvalidState as state_error: common.raise_http_conflict_for_instance_invalid_state( state_error, 'rebuild', id) except exception.InstanceNotFound: msg = _("Instance could not be found") raise exc.HTTPNotFound(explanation=msg) except exception.ImageNotFound: msg = _("Cannot find image for rebuild") raise exc.HTTPBadRequest(explanation=msg) except exception.QuotaError as error: raise exc.HTTPForbidden(explanation=error.format_message()) except (exception.ImageNotActive, exception.FlavorDiskTooSmall, exception.FlavorMemoryTooSmall, exception.InvalidMetadata, exception.AutoDiskConfigDisabledByImage) as error: raise exc.HTTPBadRequest(explanation=error.format_message()) instance = self._get_server(context, req, id) view = self._view_builder.show(req, instance, extend_address=False) # Add on the admin_password attribute since the view doesn't do it # unless instance passwords are disabled if CONF.enable_instance_password: view['server']['adminPass'] = password robj = wsgi.ResponseObject(view) return self._add_location(robj)
def _retrieve_key(self, req, match_object, user_request_id): unified_id = int(match_object.group("unified_id")) conjoined_part = int(match_object.group("conjoined_part")) lower_bound = 0 upper_bound = None slice_offset = 0 slice_size = None total_file_size = None if "range" in req.headers: lower_bound, upper_bound, slice_offset, slice_size = \ _parse_range_header(req.headers["range"]) if not "x-nimbus-io-expected-content-length" in req.headers: message = "expected x-nimbus-io-expected-content-length header" self._log.error("request {0} {1}".format( user_request_id, message)) raise exc.HTTPBadRequest(message) total_file_size = \ int(req.headers["x-nimbus-io-expected-content-length"]) assert slice_offset % block_size == 0, slice_offset block_offset = slice_offset / block_size if slice_size is None: block_count = None else: assert slice_size % block_size == 0, slice_size block_count = slice_size / block_size connected_data_readers = _connected_clients(self.data_readers) if len(connected_data_readers) < _min_connected_clients: self._log.error("request {0} too few connected readers {1}".format( user_request_id, len(connected_data_readers))) raise exc.HTTPServiceUnavailable( "Too few connected readers {0}".format( len(connected_data_readers))) result = self._get_params_from_memcache(unified_id, conjoined_part) if result is None: self._log.warn("request {0} cache miss unified-id {1} {2}".format( user_request_id, unified_id, conjoined_part)) result = self._get_params_from_database(unified_id, conjoined_part) if result is None: error_message = "unknown unified-id {0} {1}".format( unified_id, conjoined_part) self._log.error("request {0} {1}".format(user_request_id, error_message)) raise exc.HTTPServiceUnavailable(error_message) collection_id, key = result description = "request {0} retrieve: ({1}) key={2} unified_id={3}-{4} {5}:{6}".format( user_request_id, collection_id, key, unified_id, conjoined_part, slice_offset, slice_size) self._log.info(description) start_time = time.time() self._stats["retrieves"] += 1 retriever = Retriever(self._node_local_connection, self.data_readers, collection_id, key, unified_id, conjoined_part, block_offset, block_count, _min_segments, user_request_id) retrieved = retriever.retrieve(_reply_timeout) try: first_segments = retrieved.next() except RetrieveFailedError, instance: self._log.error("retrieve failed: {0} {1}".format( description, instance)) self._stats["retrieves"] -= 1 return exc.HTTPNotFound(str(instance))
def _get_instance(self, context, instance_id): try: return self.compute_api.get(context, instance_id) except exception.InstanceNotFound as e: raise exc.HTTPNotFound(explanation=e.format_message())
def create(self, req, body): """Creates a new share.""" context = req.environ['manila.context'] if not self.is_valid_body(body, 'share'): raise exc.HTTPUnprocessableEntity() share = body['share'] # NOTE(rushiagr): v2 API allows name instead of display_name if share.get('name'): share['display_name'] = share.get('name') del share['name'] # NOTE(rushiagr): v2 API allows description instead of # display_description if share.get('description'): share['display_description'] = share.get('description') del share['description'] size = share['size'] share_proto = share['share_proto'].upper() msg = (_LI("Create %(share_proto)s share of %(size)s GB") % { 'share_proto': share_proto, 'size': size }) LOG.info(msg, context=context) kwargs = {} kwargs['availability_zone'] = share.get('availability_zone') kwargs['metadata'] = share.get('metadata', None) snapshot_id = share.get('snapshot_id') if snapshot_id: snapshot = self.share_api.get_snapshot(context, snapshot_id) else: snapshot = None kwargs['snapshot'] = snapshot share_network_id = share.get('share_network_id') if snapshot: # Need to check that share_network_id from snapshot's # parents share equals to share_network_id from args. # If share_network_id is empty than update it with # share_network_id of parent share. parent_share = self.share_api.get(context, snapshot['share_id']) parent_share_net_id = parent_share['share_network_id'] if share_network_id: if share_network_id != parent_share_net_id: msg = "Share network ID should be the same as snapshot's" \ " parent share's or empty" raise exc.HTTPBadRequest(explanation=msg) elif parent_share_net_id: share_network_id = parent_share_net_id if share_network_id: try: self.share_api.get_share_network(context, share_network_id) except exception.ShareNetworkNotFound as e: raise exc.HTTPNotFound(explanation=six.text_type(e)) kwargs['share_network_id'] = share_network_id display_name = share.get('display_name') display_description = share.get('display_description') req_volume_type = share.get('volume_type', None) if req_volume_type: try: if not uuidutils.is_uuid_like(req_volume_type): kwargs['volume_type'] = \ volume_types.get_volume_type_by_name( context, req_volume_type) else: kwargs['volume_type'] = volume_types.get_volume_type( context, req_volume_type) except exception.VolumeTypeNotFound: msg = _("Volume type not found.") raise exc.HTTPNotFound(explanation=msg) new_share = self.share_api.create(context, share_proto, size, display_name, display_description, **kwargs) return self._view_builder.detail(req, dict(six.iteritems(new_share)))
def test_get_bridge_not_found(self): self.mock_api.get_bridge.side_effect = w_exc.HTTPNotFound() self.assertRaises(midonet_lib.MidonetResourceNotFound, self.client.get_bridge, uuidutils.generate_uuid())
def __call__(self, request: Request): for router in self.ROUTERs: response = router.match(request) if response: # handler(request) 返回的就是处理好的对象,直接抛给浏览器 return response raise exc.HTTPNotFound("wrongpage")
def license_deed_view(request): """ The main and major deed generating view. """ ########################## # Try and get the license. ########################## license = by_code( request.matchdict['code'], jurisdiction=request.matchdict.get('jurisdiction'), version=request.matchdict.get('version')) if not license: license_versions = util.catch_license_versions_from_request(request) if license_versions: # If we can't get it, but others of that code exist, give # a special 404. return license_catcher(request) else: # Otherwise, give the normal 404. return exc.HTTPNotFound() #################### # Everything else ;) #################### # "color" of the license; the color reflects the relative amount # of freedom. if license.license_code in ('devnations', 'sampling'): color = 'red' elif license.license_code.find('sampling') > -1 or \ license.license_code.find('nc') > -1 or \ license.license_code.find('nd') > -1: color = 'yellow' else: color = 'green' # Get the language this view will be displayed in. # - First checks to see if the routing matchdict specifies the language # - Or, next gets the jurisdictions' default language if the jurisdiction # specifies one # - Otherwise it's english! if request.matchdict.has_key('target_lang'): target_lang = request.matchdict.get('target_lang') elif license.jurisdiction.default_language: target_lang = locale_to_lower_upper( license.jurisdiction.default_language) else: target_lang = 'en' # True if the legalcode for this license is available in # multiple languages (or a single language with a language code different # than that of the jurisdiction). # # Stored in the RDF, we'll just check license.legalcodes() :) legalcodes = license.legalcodes(target_lang) if len(legalcodes) > 1 \ or list(legalcodes)[0][2] is not None: multi_language = True legalcodes = sorted(legalcodes, key=lambda lc: lc[2]) else: multi_language = False # Use the lower-dash style for all RDF-related locale stuff rdf_style_target_lang = locale_to_lower_lower(target_lang) license_title = None try: license_title = license.title(rdf_style_target_lang) except KeyError: # don't have one for that language, use default license_title = license.title() conditions = {} for code in license.license_code.split('-'): conditions[code] = 1 # Find out all the active languages active_languages = get_well_translated_langs() negotiated_locale = negotiate_locale(target_lang) # If negotiating the locale says that this isn't a valid language, # let's fall back to something that is. if target_lang != negotiated_locale: base_url = REMOVE_DEED_URL_RE.match(request.path_info).groups()[0] redirect_to = base_url + 'deed.' + negotiated_locale return exc.HTTPFound(location=redirect_to) if DEED_TEMPLATE_MAPPING.has_key(license.license_code): main_template = DEED_TEMPLATE_MAPPING[license.license_code] else: main_template = 'licenses/standard_deed.html' get_this = "/choose/results-one?license_code=%s&jurisdiction=%s&version=%s&lang=%s" % (urllib.quote(license.license_code), license.jurisdiction.code, license.version, target_lang) context = { 'request': request, 'license_code': license.license_code, 'license_code_quoted': urllib.quote(license.license_code), 'license_title': license_title, 'license': license, 'multi_language': multi_language, 'legalcodes': legalcodes, 'color': color, 'conditions': conditions, 'active_languages': active_languages, 'target_lang': target_lang, 'jurisdiction':license.jurisdiction.code, 'get_this': get_this, } context.update(util.rtl_context_stuff(target_lang)) return Response( util.render_template( request, target_lang, main_template, context))
def create(self, req, body): """Creates a new volume.""" if not self.is_valid_body(body, 'volume'): raise exc.HTTPBadRequest() context = req.environ['cinder.context'] volume = body['volume'] kwargs = {} # NOTE(thingee): v2 API allows name instead of display_name if volume.get('name'): volume['display_name'] = volume.get('name') del volume['name'] # NOTE(thingee): v2 API allows description instead of description if volume.get('description'): volume['display_description'] = volume.get('description') del volume['description'] req_volume_type = volume.get('volume_type', None) if req_volume_type: try: kwargs['volume_type'] = volume_types.get_volume_type( context, req_volume_type) except exception.VolumeTypeNotFound: explanation = 'Volume type not found.' raise exc.HTTPNotFound(explanation=explanation) kwargs['metadata'] = volume.get('metadata', None) snapshot_id = volume.get('snapshot_id') if snapshot_id is not None: kwargs['snapshot'] = self.volume_api.get_snapshot( context, snapshot_id) else: kwargs['snapshot'] = None source_volid = volume.get('source_volid') if source_volid is not None: kwargs['source_volume'] = self.volume_api.get_volume( context, source_volid) else: kwargs['source_volume'] = None size = volume.get('size', None) if size is None and kwargs['snapshot'] is not None: size = kwargs['snapshot']['volume_size'] elif size is None and kwargs['source_volume'] is not None: size = kwargs['source_volume']['size'] LOG.audit(_("Create volume of %s GB"), size, context=context) image_href = None image_uuid = None if self.ext_mgr.is_loaded('os-image-create'): image_href = volume.get('imageRef') if image_href: image_uuid = self._image_uuid_from_href(image_href) kwargs['image_id'] = image_uuid kwargs['availability_zone'] = volume.get('availability_zone', None) new_volume = self.volume_api.create(context, size, volume.get('display_name'), volume.get('display_description'), **kwargs) # TODO(vish): Instance should be None at db layer instead of # trying to lazy load, but for now we turn it into # a dict to avoid an error. retval = self._view_builder.summary(req, dict(new_volume.iteritems())) return retval
def update(self, req, id, body): """Updates an existing image with the registry. :param req: wsgi Request object :param body: Dictionary of information about the image :param id: The opaque internal identifier for the image :retval Returns the updated image information as a mapping, """ image_data = body['image'] from_state = body.get('from_state', None) # Prohibit modification of 'owner' if not req.context.is_admin and 'owner' in image_data: del image_data['owner'] if 'location' in image_data: image_data['locations'] = [image_data.pop('location')] purge_props = req.headers.get("X-Glance-Registry-Purge-Props", "false") try: LOG.debug( "Updating image %(id)s with metadata: %(image_data)r", { 'id': id, 'image_data': dict((k, v) for k, v in image_data.items() if k != 'locations') }) image_data = _normalize_image_location_for_db(image_data) if purge_props == "true": purge_props = True else: purge_props = False updated_image = self.db_api.image_update(req.context, id, image_data, purge_props=purge_props, from_state=from_state) msg = _LI("Updating metadata for image %(id)s") % {'id': id} LOG.info(msg) return dict(image=make_image_dict(updated_image)) except exception.Invalid as e: msg = (_("Failed to update image metadata. " "Got error: %s") % utils.exception_to_str(e)) LOG.error(msg) return exc.HTTPBadRequest(msg) except exception.NotFound: msg = _LI("Image %(id)s not found") % {'id': id} LOG.info(msg) raise exc.HTTPNotFound(body='Image not found', request=req, content_type='text/plain') except exception.ForbiddenPublicImage: msg = _LI("Update denied for public image %(id)s") % {'id': id} LOG.info(msg) raise exc.HTTPForbidden() except exception.Forbidden: # If it's private and doesn't belong to them, don't let on # that it exists msg = _LI("Access denied to image %(id)s but returning" " 'not found'") % { 'id': id } LOG.info(msg) raise exc.HTTPNotFound(body='Image not found', request=req, content_type='text/plain') except exception.Conflict as e: LOG.info(utils.exception_to_str(e)) raise exc.HTTPConflict(body='Image operation conflicts', request=req, content_type='text/plain') except Exception: LOG.exception(_LE("Unable to update image %s") % id) raise
def _lookup(self, *args): if args: return NamedController(args[0]), args[1:] else: raise exc.HTTPNotFound()
def _lookup(self, year, month, name, *rest): slug = '/'.join((year, month, urllib2.unquote(name).decode('utf-8'))) post = BM.BlogPost.query.get(slug=slug, app_config_id=c.app.config._id) if post is None: raise exc.HTTPNotFound() return PostController(post), rest
def detach(self, req, id, body): server_id = id context = req.environ['nova.context'] authorize_detach(context) volume_id = body['detach']['volume_id'] LOG.audit( _("Detach volume %(volume_id)s from " "instance %(server_id)s"), { "volume_id": volume_id, "server_id": id, "context": context }) instance = common.get_instance(self.compute_api, context, server_id, want_objects=True) try: volume = self.volume_api.get(context, volume_id) except exception.VolumeNotFound as e: raise exc.HTTPNotFound(explanation=e.format_message()) bdms = objects.BlockDeviceMappingList.get_by_instance_uuid( context, instance.uuid) if not bdms: msg = _("Volume %(volume_id)s is not attached to the " "instance %(server_id)s") % { 'server_id': server_id, 'volume_id': volume_id } LOG.debug(msg) raise exc.HTTPNotFound(explanation=msg) for bdm in bdms: if bdm.volume_id != volume_id: continue if bdm.is_root: msg = _("Can't detach root device volume") raise exc.HTTPForbidden(explanation=msg) try: self.compute_api.detach_volume(context, instance, volume) break except exception.VolumeUnattached: # The volume is not attached. Treat it as NotFound # by falling through. pass except exception.InvalidVolume as e: raise exc.HTTPBadRequest(explanation=e.format_message()) except exception.InstanceIsLocked as e: raise exc.HTTPConflict(explanation=e.format_message()) except exception.InstanceInvalidState as state_error: common.raise_http_conflict_for_instance_invalid_state( state_error, 'detach_volume') else: msg = _("Volume %(volume_id)s is not attached to the " "instance %(server_id)s") % { 'server_id': server_id, 'volume_id': volume_id } raise exc.HTTPNotFound(explanation=msg)