Python i18n._函数代码示例

    def update(self, req, image_id, member_id, status):
        """
        Adds a membership to the image.
        :param req: the Request object coming from the wsgi layer
        :param image_id: the image identifier
        :param member_id: the member identifier
        :returns: The response body is a mapping of the following form

        .. code-block:: json

            {'member_id': <MEMBER>,
             'image_id': <IMAGE>,
             'status': <MEMBER_STATUS>,
             'created_at': ..,
             'updated_at': ..}

        """
        image = self._lookup_image(req, image_id)
        member_repo = self._get_member_repo(req, image)
        member = self._lookup_member(req, image, member_id)
        try:
            member.status = status
            member_repo.save(member)
            return member
        except exception.Forbidden:
            msg = _("Not allowed to update members for image %s.") % image_id
            LOG.warning(msg)
            raise webob.exc.HTTPForbidden(explanation=msg)
        except ValueError as e:
            msg = (_("Incorrect request: %s")
                   % encodeutils.exception_to_unicode(e))
            LOG.warning(msg)
            raise webob.exc.HTTPBadRequest(explanation=msg)

def replication_size(options, args):
    """%(prog)s size <server:port>

    Determine the size of a xmonitor instance if dumped to disk.

    server:port: the location of the xmonitor instance.
    """

    # Make sure server info is provided
    if len(args) < 1:
        raise TypeError(_("Too few arguments."))

    server, port = utils.parse_valid_host_port(args.pop())

    total_size = 0
    count = 0

    imageservice = get_image_service()
    client = imageservice(http_client.HTTPConnection(server, port),
                          options.slavetoken)
    for image in client.get_images():
        LOG.debug('Considering image: %(image)s', {'image': image})
        if image['status'] == 'active':
            total_size += int(image['size'])
            count += 1

    print(_('Total size is %(size)d bytes across %(img_count)d images') %
          {'size': total_size,
           'img_count': count})

    def index(self, req, image_id):
        """
        Return a list of dictionaries indicating the members of the
        image, i.e., those tenants the image is shared with.

        :param req: the Request object coming from the wsgi layer
        :param image_id: The opaque image identifier
        :returns: The response body is a mapping of the following form

        .. code-block:: json

            {'members': [
                {'member_id': <MEMBER>,
                 'can_share': <SHARE_PERMISSION>, ...}, ...
            ]}

        """
        self._enforce(req, 'get_members')
        self._raise_404_if_image_deleted(req, image_id)

        try:
            members = registry.get_image_members(req.context, image_id)
        except exception.NotFound:
            msg = _("Image with identifier %s not found") % image_id
            LOG.warn(msg)
            raise webob.exc.HTTPNotFound(msg)
        except exception.Forbidden:
            msg = _("Unauthorized image access")
            LOG.warn(msg)
            raise webob.exc.HTTPForbidden(msg)
        return dict(members=members)

 def update(self, req, id, type_name, type_version, changes, **kwargs):
     """Performs an update via json patch request"""
     artifact_repo = self.gateway.get_artifact_repo(req.context)
     try:
         artifact = self._get_artifact_with_dependencies(artifact_repo, id,
                                                         type_name,
                                                         type_version)
         self._ensure_write_access(artifact, req.context)
         updated = artifact
         for change in changes:
             if artifact.metadata.attributes.blobs.get(change['path']):
                 msg = _('Invalid request PATCH for work with blob')
                 raise webob.exc.HTTPBadRequest(explanation=msg)
             else:
                 updated = self._do_update_op(updated, change)
         artifact_repo.save(updated)
         return self._get_artifact_with_dependencies(artifact_repo, id)
     except (exception.InvalidJsonPatchPath,
             exception.Invalid) as e:
         raise webob.exc.HTTPBadRequest(explanation=e.msg)
     except exception.NotFound as e:
         raise webob.exc.HTTPNotFound(explanation=e.msg)
     except exception.Forbidden as e:
         raise webob.exc.HTTPForbidden(explanation=e.msg)
     except exception.StorageQuotaFull as e:
         msg = (_("Denying attempt to upload artifact because it exceeds "
                  "the quota: %s") % encodeutils.exception_to_unicode(e))
         raise webob.exc.HTTPRequestEntityTooLarge(
             explanation=msg, request=req, content_type='text/plain')
     except exception.LimitExceeded as e:
         raise webob.exc.HTTPRequestEntityTooLarge(
             explanation=e.msg, request=req, content_type='text/plain')
     except exception.NotAuthenticated as e:
         raise webob.exc.HTTPUnauthorized(explanation=e.msg)

    def launch(pid_file, conf_file=None, capture_output=False, await_time=0):
        args = [server]
        if conf_file:
            args += ['--config-file', conf_file]
            msg = (_('%(verb)sing %(serv)s with %(conf)s') %
                   {'verb': verb, 'serv': server, 'conf': conf_file})
        else:
            msg = (_('%(verb)sing %(serv)s') % {'verb': verb, 'serv': server})
        print(msg)

        close_stdio_on_exec()

        pid = os.fork()
        if pid == 0:
            os.setsid()
            redirect_stdio(server, capture_output)
            try:
                os.execlp('%s' % server, *args)
            except OSError as e:
                msg = (_('unable to launch %(serv)s. Got error: %(e)s') %
                       {'serv': server, 'e': e})
                sys.exit(msg)
            sys.exit(0)
        else:
            write_pid_file(pid_file, pid)
            await_child(pid, await_time)
            return pid

def _get_base_properties():
    return {
        "name": {
            "type": "string"
        },
        "description": {
            "type": "string"
        },
        "required": {
            "$ref": "#/definitions/stringArray"
        },
        "properties": {
            "$ref": "#/definitions/property"
        },
        "schema": {
            'readOnly': True,
            "type": "string"
        },
        "self": {
            'readOnly': True,
            "type": "string"
        },
        "created_at": {
            "type": "string",
            "readOnly": True,
            "description": _("Date and time of object creation"),
            "format": "date-time"
        },
        "updated_at": {
            "type": "string",
            "readOnly": True,
            "description": _("Date and time of the last object modification"),
            "format": "date-time"
        }
    }

    def status(self, status):
        has_status = hasattr(self, '_status')
        if has_status:
            if status not in self.valid_state_targets[self._status]:
                kw = {'cur_status': self._status, 'new_status': status}
                e = exception.InvalidImageStatusTransition(**kw)
                LOG.debug(e)
                raise e

            if self._status == 'queued' and status in ('saving', 'active'):
                missing = [k for k in ['disk_format', 'container_format']
                           if not getattr(self, k)]
                if len(missing) > 0:
                    if len(missing) == 1:
                        msg = _('Property %s must be set prior to '
                                'saving data.')
                    else:
                        msg = _('Properties %s must be set prior to '
                                'saving data.')
                    raise ValueError(msg % ', '.join(missing))
        # NOTE(flwang): Image size should be cleared as long as the image
        # status is updated to 'queued'
        if status == 'queued':
            self.size = None
            self.virtual_size = None
        self._status = status

 def update(self, req, image_id, tag_value):
     image_repo = self.gateway.get_repo(req.context)
     try:
         image = image_repo.get(image_id)
         image.tags.add(tag_value)
         image_repo.save(image)
     except exception.NotFound:
         msg = _("Image %s not found.") % image_id
         LOG.warning(msg)
         raise webob.exc.HTTPNotFound(explanation=msg)
     except exception.Forbidden:
         msg = _("Not allowed to update tags for image %s.") % image_id
         LOG.warning(msg)
         raise webob.exc.HTTPForbidden(explanation=msg)
     except exception.Invalid as e:
         msg = (_("Could not update image: %s")
                % encodeutils.exception_to_unicode(e))
         LOG.warning(msg)
         raise webob.exc.HTTPBadRequest(explanation=msg)
     except exception.ImageTagLimitExceeded as e:
         msg = (_("Image tag limit exceeded for image %(id)s: %(e)s:")
                % {"id": image_id,
                   "e": encodeutils.exception_to_unicode(e)})
         LOG.warning(msg)
         raise webob.exc.HTTPRequestEntityTooLarge(explanation=msg)

 def download(self, req, id, type_name, type_version, attr, index,
              **kwargs):
     artifact_repo = self.gateway.get_artifact_repo(req.context)
     try:
         artifact = artifact_repo.get(id, type_name, type_version)
         if attr in artifact.metadata.attributes.blobs:
             if isinstance(artifact.metadata.attributes.blobs[attr], list):
                 if index is None:
                     raise webob.exc.HTTPBadRequest(
                         explanation=_("Index is required"))
                 blob_list = getattr(artifact, attr)
                 try:
                     return blob_list[index]
                 except IndexError as e:
                     raise webob.exc.HTTPBadRequest(explanation=e.message)
             else:
                 if index is not None:
                     raise webob.exc.HTTPBadRequest(_("Not a list "
                                                      "property"))
                 return getattr(artifact, attr)
         else:
             message = _("Not a downloadable entity")
             raise webob.exc.HTTPBadRequest(explanation=message)
     except exception.Forbidden as e:
         raise webob.exc.HTTPForbidden(explanation=e.msg)
     except (glance_store.NotFound, exception.NotFound) as e:
         raise webob.exc.HTTPNotFound(explanation=e.msg)
     except exception.Invalid as e:
         raise webob.exc.HTTPBadRequest(explanation=e.msg)

    def __init__(self, type_name=None, type_version=None, **kwargs):
        """Defines an artifact reference

        :param type_name: type name of the target artifact
        :param type_version: type version of the target artifact
        """
        super(ArtifactReference, self).__init__(**kwargs)
        if type_name is not None:
            if isinstance(type_name, list):
                type_names = list(type_name)
                if type_version is not None:
                    raise exc.InvalidArtifactTypePropertyDefinition(
                        _('Unable to specify version '
                          'if multiple types are possible'))
            else:
                type_names = [type_name]

            def validate_reference(artifact):
                if artifact.type_name not in type_names:
                    return False
                if (type_version is not None and
                   artifact.type_version != type_version):
                    return False
                return True

            self._add_validator('referenced_type',
                                validate_reference,
                                _("Invalid referenced type"))
        elif type_version is not None:
            raise exc.InvalidArtifactTypePropertyDefinition(
                _('Unable to specify version '
                  'if type is not specified'))
        self._check_definition()

 def _check_item_type(self, item):
     if not isinstance(item, self.ALLOWED_ITEM_TYPES):
         raise exc.InvalidArtifactTypePropertyDefinition(
             _('Invalid item type specification'))
     if item.default is not None:
         raise exc.InvalidArtifactTypePropertyDefinition(
             _('List definitions may hot have defaults'))

def validate_location_uri(location):
    """Validate location uri into acceptable format.

    :param location: Location uri to be validated
    """
    if not location:
        raise exception.BadStoreUri(_('Invalid location: %s') % location)

    elif location.startswith(('http://', 'https://')):
        return location

    # NOTE: file type uri is being avoided for security reasons,
    # see LP bug #942118 #1400966.
    elif location.startswith(("file:///", "filesystem:///")):
        msg = _("File based imports are not allowed. Please use a non-local "
                "source of image data.")
        # NOTE: raise BadStoreUri and let the encompassing block save the error
        # msg in the task.message.
        raise exception.BadStoreUri(msg)

    else:
        # TODO(nikhil): add other supported uris
        supported = ['http', ]
        msg = _("The given uri is not valid. Please specify a "
                "valid uri from the following list of supported uri "
                "%(supported)s") % {'supported': supported}
        raise urllib.error.URLError(msg)

def configure_registry_client():
    """
    Sets up a registry client for use in registry lookups
    """
    global _CLIENT_KWARGS, _CLIENT_HOST, _CLIENT_PORT
    try:
        host, port = CONF.registry_host, CONF.registry_port
    except cfg.ConfigFileValueError:
        msg = _("Configuration option was not valid")
        LOG.error(msg)
        raise exception.BadRegistryConnectionConfiguration(msg)
    except IndexError:
        msg = _("Could not find required configuration option")
        LOG.error(msg)
        raise exception.BadRegistryConnectionConfiguration(msg)

    _CLIENT_HOST = host
    _CLIENT_PORT = port
    _CLIENT_KWARGS = {
        'use_ssl': CONF.registry_client_protocol.lower() == 'https',
        'key_file': CONF.registry_client_key_file,
        'cert_file': CONF.registry_client_cert_file,
        'ca_file': CONF.registry_client_ca_file,
        'insecure': CONF.registry_client_insecure,
        'timeout': CONF.registry_client_timeout,
    }

    if not CONF.use_user_token:
        configure_registry_admin_creds()

def do_stop(server, args, graceful=False):
    if graceful and server in GRACEFUL_SHUTDOWN_SERVERS:
        sig = signal.SIGHUP
    else:
        sig = signal.SIGTERM

    did_anything = False
    pfiles = pid_files(server, CONF.pid_file)
    for pid_file, pid in pfiles:
        did_anything = True
        try:
            os.unlink(pid_file)
        except OSError:
            pass
        try:
            print(_('Stopping %(serv)s (pid %(pid)s) with signal(%(sig)s)')
                  % {'serv': server, 'pid': pid, 'sig': sig})
            os.kill(pid, sig)
        except OSError:
            print(_("Process %d not running") % pid)
    for pid_file, pid in pfiles:
        for _junk in range(150):  # 15 seconds
            if not os.path.exists('/proc/%s' % pid):
                break
            time.sleep(0.1)
        else:
            print(_('Waited 15 seconds for pid %(pid)s (%(file)s) to die;'
                    ' giving up') % {'pid': pid, 'file': pid_file})
    if not did_anything:
        print(_('%s is already stopped') % server)

 def set_attr(self, value):
     if not isinstance(value, (list, StoreLocations)):
         reason = _('Invalid locations')
         raise exception.BadStoreUri(message=reason)
     ori_value = getattr(getattr(self, target), attr)
     if ori_value != value:
         # NOTE(flwang): If all the URL of passed-in locations are same as
         # current image locations, that means user would like to only
         # update the metadata, not the URL.
         ordered_value = sorted([loc['url'] for loc in value])
         ordered_ori = sorted([loc['url'] for loc in ori_value])
         if len(ori_value) > 0 and ordered_value != ordered_ori:
             raise exception.Invalid(_('Original locations is not empty: '
                                       '%s') % ori_value)
         # NOTE(zhiyan): Check locations are all valid
         # NOTE(flwang): If all the URL of passed-in locations are same as
         # current image locations, then it's not necessary to verify those
         # locations again. Otherwise, if there is any restricted scheme in
         # existing locations. _check_image_location will fail.
         if ordered_value != ordered_ori:
             for loc in value:
                 _check_image_location(self.context,
                                       self.store_api,
                                       self.store_utils,
                                       loc)
                 loc['status'] = 'active'
                 if _count_duplicated_locations(value, loc) > 1:
                     raise exception.DuplicateLocation(location=loc['url'])
             _set_image_size(self.context, getattr(self, target), value)
         else:
             for loc in value:
                 loc['status'] = 'active'
         return setattr(getattr(self, target), attr, list(value))