First round of i18n-ifying strings in Nova
This commit is contained in:
		@@ -37,7 +37,6 @@ class DbDriver(object):
 | 
			
		||||
    def __init__(self):
 | 
			
		||||
        """Imports the LDAP module"""
 | 
			
		||||
        pass
 | 
			
		||||
        db
 | 
			
		||||
 | 
			
		||||
    def __enter__(self):
 | 
			
		||||
        return self
 | 
			
		||||
@@ -83,7 +82,7 @@ class DbDriver(object):
 | 
			
		||||
            user_ref = db.user_create(context.get_admin_context(), values)
 | 
			
		||||
            return self._db_user_to_auth_user(user_ref)
 | 
			
		||||
        except exception.Duplicate, e:
 | 
			
		||||
            raise exception.Duplicate('User %s already exists' % name)
 | 
			
		||||
            raise exception.Duplicate(_('User %s already exists') % name)
 | 
			
		||||
 | 
			
		||||
    def _db_user_to_auth_user(self, user_ref):
 | 
			
		||||
        return {'id': user_ref['id'],
 | 
			
		||||
@@ -105,8 +104,9 @@ class DbDriver(object):
 | 
			
		||||
        """Create a project"""
 | 
			
		||||
        manager = db.user_get(context.get_admin_context(), manager_uid)
 | 
			
		||||
        if not manager:
 | 
			
		||||
            raise exception.NotFound("Project can't be created because "
 | 
			
		||||
                                     "manager %s doesn't exist" % manager_uid)
 | 
			
		||||
            raise exception.NotFound(_("Project can't be created because "
 | 
			
		||||
                                       "manager %s doesn't exist")
 | 
			
		||||
                                     % manager_uid)
 | 
			
		||||
 | 
			
		||||
        # description is a required attribute
 | 
			
		||||
        if description is None:
 | 
			
		||||
@@ -133,8 +133,8 @@ class DbDriver(object):
 | 
			
		||||
        try:
 | 
			
		||||
            project = db.project_create(context.get_admin_context(), values)
 | 
			
		||||
        except exception.Duplicate:
 | 
			
		||||
            raise exception.Duplicate("Project can't be created because "
 | 
			
		||||
                                      "project %s already exists" % name)
 | 
			
		||||
            raise exception.Duplicate(_("Project can't be created because "
 | 
			
		||||
                                        "project %s already exists") % name)
 | 
			
		||||
 | 
			
		||||
        for member in members:
 | 
			
		||||
            db.project_add_member(context.get_admin_context(),
 | 
			
		||||
@@ -155,8 +155,8 @@ class DbDriver(object):
 | 
			
		||||
        if manager_uid:
 | 
			
		||||
            manager = db.user_get(context.get_admin_context(), manager_uid)
 | 
			
		||||
            if not manager:
 | 
			
		||||
                raise exception.NotFound("Project can't be modified because "
 | 
			
		||||
                                          "manager %s doesn't exist" %
 | 
			
		||||
                raise exception.NotFound(_("Project can't be modified because "
 | 
			
		||||
                                           "manager %s doesn't exist") %
 | 
			
		||||
                                          manager_uid)
 | 
			
		||||
            values['project_manager'] = manager['id']
 | 
			
		||||
        if description:
 | 
			
		||||
@@ -243,8 +243,8 @@ class DbDriver(object):
 | 
			
		||||
    def _validate_user_and_project(self, user_id, project_id):
 | 
			
		||||
        user = db.user_get(context.get_admin_context(), user_id)
 | 
			
		||||
        if not user:
 | 
			
		||||
            raise exception.NotFound('User "%s" not found' % user_id)
 | 
			
		||||
            raise exception.NotFound(_('User "%s" not found') % user_id)
 | 
			
		||||
        project = db.project_get(context.get_admin_context(), project_id)
 | 
			
		||||
        if not project:
 | 
			
		||||
            raise exception.NotFound('Project "%s" not found' % project_id)
 | 
			
		||||
            raise exception.NotFound(_('Project "%s" not found') % project_id)
 | 
			
		||||
        return user, project
 | 
			
		||||
 
 | 
			
		||||
@@ -39,7 +39,7 @@ flags.DEFINE_integer('redis_db', 0, 'Multiple DB keeps tests away')
 | 
			
		||||
class Redis(object):
 | 
			
		||||
    def __init__(self):
 | 
			
		||||
        if hasattr(self.__class__, '_instance'):
 | 
			
		||||
            raise Exception('Attempted to instantiate singleton')
 | 
			
		||||
            raise Exception(_('Attempted to instantiate singleton'))
 | 
			
		||||
 | 
			
		||||
    @classmethod
 | 
			
		||||
    def instance(cls):
 | 
			
		||||
 
 | 
			
		||||
@@ -159,7 +159,7 @@ class LdapDriver(object):
 | 
			
		||||
                self.conn.modify_s(self.__uid_to_dn(name), attr)
 | 
			
		||||
                return self.get_user(name)
 | 
			
		||||
            else:
 | 
			
		||||
                raise exception.NotFound("LDAP object for %s doesn't exist"
 | 
			
		||||
                raise exception.NotFound(_("LDAP object for %s doesn't exist")
 | 
			
		||||
                                         % name)
 | 
			
		||||
        else:
 | 
			
		||||
            attr = [
 | 
			
		||||
@@ -182,11 +182,12 @@ class LdapDriver(object):
 | 
			
		||||
                       description=None, member_uids=None):
 | 
			
		||||
        """Create a project"""
 | 
			
		||||
        if self.__project_exists(name):
 | 
			
		||||
            raise exception.Duplicate("Project can't be created because "
 | 
			
		||||
                                      "project %s already exists" % name)
 | 
			
		||||
            raise exception.Duplicate(_("Project can't be created because "
 | 
			
		||||
                                        "project %s already exists") % name)
 | 
			
		||||
        if not self.__user_exists(manager_uid):
 | 
			
		||||
            raise exception.NotFound("Project can't be created because "
 | 
			
		||||
                                     "manager %s doesn't exist" % manager_uid)
 | 
			
		||||
            raise exception.NotFound(_("Project can't be created because "
 | 
			
		||||
                                       "manager %s doesn't exist")
 | 
			
		||||
                                     % manager_uid)
 | 
			
		||||
        manager_dn = self.__uid_to_dn(manager_uid)
 | 
			
		||||
        # description is a required attribute
 | 
			
		||||
        if description is None:
 | 
			
		||||
@@ -195,8 +196,8 @@ class LdapDriver(object):
 | 
			
		||||
        if member_uids is not None:
 | 
			
		||||
            for member_uid in member_uids:
 | 
			
		||||
                if not self.__user_exists(member_uid):
 | 
			
		||||
                    raise exception.NotFound("Project can't be created "
 | 
			
		||||
                                             "because user %s doesn't exist"
 | 
			
		||||
                    raise exception.NotFound(_("Project can't be created "
 | 
			
		||||
                                               "because user %s doesn't exist")
 | 
			
		||||
                                             % member_uid)
 | 
			
		||||
                members.append(self.__uid_to_dn(member_uid))
 | 
			
		||||
        # always add the manager as a member because members is required
 | 
			
		||||
@@ -218,9 +219,9 @@ class LdapDriver(object):
 | 
			
		||||
        attr = []
 | 
			
		||||
        if manager_uid:
 | 
			
		||||
            if not self.__user_exists(manager_uid):
 | 
			
		||||
                raise exception.NotFound("Project can't be modified because "
 | 
			
		||||
                                         "manager %s doesn't exist" %
 | 
			
		||||
                                         manager_uid)
 | 
			
		||||
                raise exception.NotFound(_("Project can't be modified because "
 | 
			
		||||
                                           "manager %s doesn't exist")
 | 
			
		||||
                                         % manager_uid)
 | 
			
		||||
            manager_dn = self.__uid_to_dn(manager_uid)
 | 
			
		||||
            attr.append((self.ldap.MOD_REPLACE, 'projectManager', manager_dn))
 | 
			
		||||
        if description:
 | 
			
		||||
@@ -416,8 +417,9 @@ class LdapDriver(object):
 | 
			
		||||
        if member_uids is not None:
 | 
			
		||||
            for member_uid in member_uids:
 | 
			
		||||
                if not self.__user_exists(member_uid):
 | 
			
		||||
                    raise exception.NotFound("Group can't be created "
 | 
			
		||||
                            "because user %s doesn't exist" % member_uid)
 | 
			
		||||
                    raise exception.NotFound(_("Group can't be created "
 | 
			
		||||
                                               "because user %s doesn't exist")
 | 
			
		||||
                                             % member_uid)
 | 
			
		||||
                members.append(self.__uid_to_dn(member_uid))
 | 
			
		||||
        dn = self.__uid_to_dn(uid)
 | 
			
		||||
        if not dn in members:
 | 
			
		||||
@@ -432,8 +434,9 @@ class LdapDriver(object):
 | 
			
		||||
    def __is_in_group(self, uid, group_dn):
 | 
			
		||||
        """Check if user is in group"""
 | 
			
		||||
        if not self.__user_exists(uid):
 | 
			
		||||
            raise exception.NotFound("User %s can't be searched in group "
 | 
			
		||||
                    "becuase the user doesn't exist" % (uid,))
 | 
			
		||||
            raise exception.NotFound(_("User %s can't be searched in group "
 | 
			
		||||
                                       "because the user doesn't exist")
 | 
			
		||||
                                     % uid)
 | 
			
		||||
        if not self.__group_exists(group_dn):
 | 
			
		||||
            return False
 | 
			
		||||
        res = self.__find_object(group_dn,
 | 
			
		||||
@@ -444,28 +447,30 @@ class LdapDriver(object):
 | 
			
		||||
    def __add_to_group(self, uid, group_dn):
 | 
			
		||||
        """Add user to group"""
 | 
			
		||||
        if not self.__user_exists(uid):
 | 
			
		||||
            raise exception.NotFound("User %s can't be added to the group "
 | 
			
		||||
                    "becuase the user doesn't exist" % (uid,))
 | 
			
		||||
            raise exception.NotFound(_("User %s can't be added to the group "
 | 
			
		||||
                                       "because the user doesn't exist")
 | 
			
		||||
                                     % uid)
 | 
			
		||||
        if not self.__group_exists(group_dn):
 | 
			
		||||
            raise exception.NotFound("The group at dn %s doesn't exist" %
 | 
			
		||||
                                     (group_dn,))
 | 
			
		||||
            raise exception.NotFound(_("The group at dn %s doesn't exist")
 | 
			
		||||
                                     % group_dn)
 | 
			
		||||
        if self.__is_in_group(uid, group_dn):
 | 
			
		||||
            raise exception.Duplicate("User %s is already a member of "
 | 
			
		||||
                                      "the group %s" % (uid, group_dn))
 | 
			
		||||
            raise exception.Duplicate(_("User %s is already a member of "
 | 
			
		||||
                                        "the group %s") % (uid, group_dn))
 | 
			
		||||
        attr = [(self.ldap.MOD_ADD, 'member', self.__uid_to_dn(uid))]
 | 
			
		||||
        self.conn.modify_s(group_dn, attr)
 | 
			
		||||
 | 
			
		||||
    def __remove_from_group(self, uid, group_dn):
 | 
			
		||||
        """Remove user from group"""
 | 
			
		||||
        if not self.__group_exists(group_dn):
 | 
			
		||||
            raise exception.NotFound("The group at dn %s doesn't exist" %
 | 
			
		||||
                                     (group_dn,))
 | 
			
		||||
            raise exception.NotFound(_("The group at dn %s doesn't exist")
 | 
			
		||||
                                     % group_dn)
 | 
			
		||||
        if not self.__user_exists(uid):
 | 
			
		||||
            raise exception.NotFound("User %s can't be removed from the "
 | 
			
		||||
                    "group because the user doesn't exist" % (uid,))
 | 
			
		||||
            raise exception.NotFound(_("User %s can't be removed from the "
 | 
			
		||||
                                       "group because the user doesn't exist")
 | 
			
		||||
                                     % uid)
 | 
			
		||||
        if not self.__is_in_group(uid, group_dn):
 | 
			
		||||
            raise exception.NotFound("User %s is not a member of the group" %
 | 
			
		||||
                                     (uid,))
 | 
			
		||||
            raise exception.NotFound(_("User %s is not a member of the group")
 | 
			
		||||
                                     % uid)
 | 
			
		||||
        # NOTE(vish): remove user from group and any sub_groups
 | 
			
		||||
        sub_dns = self.__find_group_dns_with_member(
 | 
			
		||||
                group_dn, uid)
 | 
			
		||||
@@ -479,15 +484,16 @@ class LdapDriver(object):
 | 
			
		||||
        try:
 | 
			
		||||
            self.conn.modify_s(group_dn, attr)
 | 
			
		||||
        except self.ldap.OBJECT_CLASS_VIOLATION:
 | 
			
		||||
            logging.debug("Attempted to remove the last member of a group. "
 | 
			
		||||
                          "Deleting the group at %s instead.", group_dn)
 | 
			
		||||
            logging.debug(_("Attempted to remove the last member of a group. "
 | 
			
		||||
                            "Deleting the group at %s instead."), group_dn)
 | 
			
		||||
            self.__delete_group(group_dn)
 | 
			
		||||
 | 
			
		||||
    def __remove_from_all(self, uid):
 | 
			
		||||
        """Remove user from all roles and projects"""
 | 
			
		||||
        if not self.__user_exists(uid):
 | 
			
		||||
            raise exception.NotFound("User %s can't be removed from all "
 | 
			
		||||
                    "because the user doesn't exist" % (uid,))
 | 
			
		||||
            raise exception.NotFound(_("User %s can't be removed from all "
 | 
			
		||||
                                       "because the user doesn't exist")
 | 
			
		||||
                                     % uid)
 | 
			
		||||
        role_dns = self.__find_group_dns_with_member(
 | 
			
		||||
                FLAGS.role_project_subtree, uid)
 | 
			
		||||
        for role_dn in role_dns:
 | 
			
		||||
@@ -500,7 +506,8 @@ class LdapDriver(object):
 | 
			
		||||
    def __delete_group(self, group_dn):
 | 
			
		||||
        """Delete Group"""
 | 
			
		||||
        if not self.__group_exists(group_dn):
 | 
			
		||||
            raise exception.NotFound("Group at dn %s doesn't exist" % group_dn)
 | 
			
		||||
            raise exception.NotFound(_("Group at dn %s doesn't exist")
 | 
			
		||||
                                     % group_dn)
 | 
			
		||||
        self.conn.delete_s(group_dn)
 | 
			
		||||
 | 
			
		||||
    def __delete_roles(self, project_dn):
 | 
			
		||||
 
 | 
			
		||||
@@ -257,12 +257,12 @@ class AuthManager(object):
 | 
			
		||||
        # TODO(vish): check for valid timestamp
 | 
			
		||||
        (access_key, _sep, project_id) = access.partition(':')
 | 
			
		||||
 | 
			
		||||
        logging.info('Looking up user: %r', access_key)
 | 
			
		||||
        logging.info(_('Looking up user: %r'), access_key)
 | 
			
		||||
        user = self.get_user_from_access_key(access_key)
 | 
			
		||||
        logging.info('user: %r', user)
 | 
			
		||||
        if user == None:
 | 
			
		||||
            raise exception.NotFound('No user found for access key %s' %
 | 
			
		||||
                                     access_key)
 | 
			
		||||
            raise exception.NotFound(_('No user found for access key %s')
 | 
			
		||||
                                     % access_key)
 | 
			
		||||
 | 
			
		||||
        # NOTE(vish): if we stop using project name as id we need better
 | 
			
		||||
        #             logic to find a default project for user
 | 
			
		||||
@@ -271,12 +271,12 @@ class AuthManager(object):
 | 
			
		||||
 | 
			
		||||
        project = self.get_project(project_id)
 | 
			
		||||
        if project == None:
 | 
			
		||||
            raise exception.NotFound('No project called %s could be found' %
 | 
			
		||||
                                     project_id)
 | 
			
		||||
            raise exception.NotFound(_('No project called %s could be found')
 | 
			
		||||
                                     % project_id)
 | 
			
		||||
        if not self.is_admin(user) and not self.is_project_member(user,
 | 
			
		||||
                                                                  project):
 | 
			
		||||
            raise exception.NotFound('User %s is not a member of project %s' %
 | 
			
		||||
                                     (user.id, project.id))
 | 
			
		||||
            raise exception.NotFound(_('User %s is not a member of project %s')
 | 
			
		||||
                                     % (user.id, project.id))
 | 
			
		||||
        if check_type == 's3':
 | 
			
		||||
            sign = signer.Signer(user.secret.encode())
 | 
			
		||||
            expected_signature = sign.s3_authorization(headers, verb, path)
 | 
			
		||||
@@ -284,7 +284,7 @@ class AuthManager(object):
 | 
			
		||||
            logging.debug('expected_signature: %s', expected_signature)
 | 
			
		||||
            logging.debug('signature: %s', signature)
 | 
			
		||||
            if signature != expected_signature:
 | 
			
		||||
                raise exception.NotAuthorized('Signature does not match')
 | 
			
		||||
                raise exception.NotAuthorized(_('Signature does not match'))
 | 
			
		||||
        elif check_type == 'ec2':
 | 
			
		||||
            # NOTE(vish): hmac can't handle unicode, so encode ensures that
 | 
			
		||||
            #             secret isn't unicode
 | 
			
		||||
@@ -294,7 +294,7 @@ class AuthManager(object):
 | 
			
		||||
            logging.debug('expected_signature: %s', expected_signature)
 | 
			
		||||
            logging.debug('signature: %s', signature)
 | 
			
		||||
            if signature != expected_signature:
 | 
			
		||||
                raise exception.NotAuthorized('Signature does not match')
 | 
			
		||||
                raise exception.NotAuthorized(_('Signature does not match'))
 | 
			
		||||
        return (user, project)
 | 
			
		||||
 | 
			
		||||
    def get_access_key(self, user, project):
 | 
			
		||||
@@ -364,7 +364,7 @@ class AuthManager(object):
 | 
			
		||||
        with self.driver() as drv:
 | 
			
		||||
            if role == 'projectmanager':
 | 
			
		||||
                if not project:
 | 
			
		||||
                    raise exception.Error("Must specify project")
 | 
			
		||||
                    raise exception.Error(_("Must specify project"))
 | 
			
		||||
                return self.is_project_manager(user, project)
 | 
			
		||||
 | 
			
		||||
            global_role = drv.has_role(User.safe_id(user),
 | 
			
		||||
@@ -398,9 +398,9 @@ class AuthManager(object):
 | 
			
		||||
        @param project: Project in which to add local role.
 | 
			
		||||
        """
 | 
			
		||||
        if role not in FLAGS.allowed_roles:
 | 
			
		||||
            raise exception.NotFound("The %s role can not be found" % role)
 | 
			
		||||
            raise exception.NotFound(_("The %s role can not be found") % role)
 | 
			
		||||
        if project is not None and role in FLAGS.global_roles:
 | 
			
		||||
            raise exception.NotFound("The %s role is global only" % role)
 | 
			
		||||
            raise exception.NotFound(_("The %s role is global only") % role)
 | 
			
		||||
        with self.driver() as drv:
 | 
			
		||||
            drv.add_role(User.safe_id(user), role, Project.safe_id(project))
 | 
			
		||||
 | 
			
		||||
@@ -546,7 +546,8 @@ class AuthManager(object):
 | 
			
		||||
                                             Project.safe_id(project))
 | 
			
		||||
 | 
			
		||||
        if not network_ref['vpn_public_port']:
 | 
			
		||||
            raise exception.NotFound('project network data has not been set')
 | 
			
		||||
            raise exception.NotFound(_('project network data has not '
 | 
			
		||||
                                       'been set'))
 | 
			
		||||
        return (network_ref['vpn_public_address'],
 | 
			
		||||
                network_ref['vpn_public_port'])
 | 
			
		||||
 | 
			
		||||
@@ -659,8 +660,7 @@ class AuthManager(object):
 | 
			
		||||
                                  port=vpn_port)
 | 
			
		||||
            zippy.writestr(FLAGS.credential_vpn_file, config)
 | 
			
		||||
        else:
 | 
			
		||||
            logging.warn("No vpn data for project %s" %
 | 
			
		||||
                                  pid)
 | 
			
		||||
            logging.warn(_("No vpn data for project %s"), pid)
 | 
			
		||||
 | 
			
		||||
        zippy.writestr(FLAGS.ca_file, crypto.fetch_ca(user.id))
 | 
			
		||||
        zippy.close()
 | 
			
		||||
 
 | 
			
		||||
@@ -30,11 +30,11 @@ class ProcessExecutionError(IOError):
 | 
			
		||||
    def __init__(self, stdout=None, stderr=None, exit_code=None, cmd=None,
 | 
			
		||||
                 description=None):
 | 
			
		||||
        if description is None:
 | 
			
		||||
            description = "Unexpected error while running command."
 | 
			
		||||
            description = _("Unexpected error while running command.")
 | 
			
		||||
        if exit_code is None:
 | 
			
		||||
            exit_code = '-'
 | 
			
		||||
        message = "%s\nCommand: %s\nExit code: %s\nStdout: %r\nStderr: %r" % (
 | 
			
		||||
                  description, cmd, exit_code, stdout, stderr)
 | 
			
		||||
        message = _("%s\nCommand: %s\nExit code: %s\nStdout: %r\nStderr: %r")\
 | 
			
		||||
                % (description, cmd, exit_code, stdout, stderr)
 | 
			
		||||
        IOError.__init__(self, message)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@@ -81,7 +81,7 @@ def wrap_exception(f):
 | 
			
		||||
        except Exception, e:
 | 
			
		||||
            if not isinstance(e, Error):
 | 
			
		||||
                #exc_type, exc_value, exc_traceback = sys.exc_info()
 | 
			
		||||
                logging.exception('Uncaught exception')
 | 
			
		||||
                logging.exception(_('Uncaught exception'))
 | 
			
		||||
                #logging.error(traceback.extract_stack(exc_traceback))
 | 
			
		||||
                raise Error(str(e))
 | 
			
		||||
            raise
 | 
			
		||||
 
 | 
			
		||||
@@ -37,12 +37,12 @@ class Exchange(object):
 | 
			
		||||
        self._routes = {}
 | 
			
		||||
 | 
			
		||||
    def publish(self, message, routing_key=None):
 | 
			
		||||
        logging.debug('(%s) publish (key: %s) %s',
 | 
			
		||||
        logging.debug(_('(%s) publish (key: %s) %s'),
 | 
			
		||||
                      self.name, routing_key, message)
 | 
			
		||||
        routing_key = routing_key.split('.')[0]
 | 
			
		||||
        if routing_key in self._routes:
 | 
			
		||||
            for f in self._routes[routing_key]:
 | 
			
		||||
                logging.debug('Publishing to route %s', f)
 | 
			
		||||
                logging.debug(_('Publishing to route %s'), f)
 | 
			
		||||
                f(message, routing_key=routing_key)
 | 
			
		||||
 | 
			
		||||
    def bind(self, callback, routing_key):
 | 
			
		||||
@@ -82,16 +82,16 @@ class Backend(object):
 | 
			
		||||
 | 
			
		||||
        def queue_declare(self, queue, **kwargs):
 | 
			
		||||
            if queue not in self._queues:
 | 
			
		||||
                logging.debug('Declaring queue %s', queue)
 | 
			
		||||
                logging.debug(_('Declaring queue %s'), queue)
 | 
			
		||||
                self._queues[queue] = Queue(queue)
 | 
			
		||||
 | 
			
		||||
        def exchange_declare(self, exchange, type, *args, **kwargs):
 | 
			
		||||
            if exchange not in self._exchanges:
 | 
			
		||||
                logging.debug('Declaring exchange %s', exchange)
 | 
			
		||||
                logging.debug(_('Declaring exchange %s'), exchange)
 | 
			
		||||
                self._exchanges[exchange] = Exchange(exchange, type)
 | 
			
		||||
 | 
			
		||||
        def queue_bind(self, queue, exchange, routing_key, **kwargs):
 | 
			
		||||
            logging.debug('Binding %s to %s with key %s',
 | 
			
		||||
            logging.debug(_('Binding %s to %s with key %s'),
 | 
			
		||||
                          queue, exchange, routing_key)
 | 
			
		||||
            self._exchanges[exchange].bind(self._queues[queue].push,
 | 
			
		||||
                                           routing_key)
 | 
			
		||||
@@ -117,7 +117,7 @@ class Backend(object):
 | 
			
		||||
                              content_type=content_type,
 | 
			
		||||
                              content_encoding=content_encoding)
 | 
			
		||||
            message.result = True
 | 
			
		||||
            logging.debug('Getting from %s: %s', queue, message)
 | 
			
		||||
            logging.debug(_('Getting from %s: %s'), queue, message)
 | 
			
		||||
            return message
 | 
			
		||||
 | 
			
		||||
        def prepare_message(self, message_data, delivery_mode,
 | 
			
		||||
 
 | 
			
		||||
@@ -131,7 +131,7 @@ def get_process_output(executable, args=None, env=None, path=None,
 | 
			
		||||
    cmd = executable
 | 
			
		||||
    if args:
 | 
			
		||||
        cmd = " ".join([cmd] + args)
 | 
			
		||||
    logging.debug("Running cmd: %s", cmd)
 | 
			
		||||
    logging.debug(_("Running cmd: %s"), cmd)
 | 
			
		||||
    process_handler = BackRelayWithInput(
 | 
			
		||||
            deferred,
 | 
			
		||||
            cmd,
 | 
			
		||||
 
 | 
			
		||||
							
								
								
									
										36
									
								
								nova/rpc.py
									
									
									
									
									
								
							
							
						
						
									
										36
									
								
								nova/rpc.py
									
									
									
									
									
								
							@@ -91,15 +91,15 @@ class Consumer(messaging.Consumer):
 | 
			
		||||
                self.failed_connection = False
 | 
			
		||||
                break
 | 
			
		||||
            except:  # Catching all because carrot sucks
 | 
			
		||||
                logging.exception("AMQP server on %s:%d is unreachable." \
 | 
			
		||||
                    " Trying again in %d seconds." % (
 | 
			
		||||
                logging.exception(_("AMQP server on %s:%d is unreachable."
 | 
			
		||||
                    " Trying again in %d seconds.") % (
 | 
			
		||||
                    FLAGS.rabbit_host,
 | 
			
		||||
                    FLAGS.rabbit_port,
 | 
			
		||||
                    FLAGS.rabbit_retry_interval))
 | 
			
		||||
                self.failed_connection = True
 | 
			
		||||
        if self.failed_connection:
 | 
			
		||||
            logging.exception("Unable to connect to AMQP server" \
 | 
			
		||||
                " after %d tries. Shutting down." % FLAGS.rabbit_max_retries)
 | 
			
		||||
            logging.exception(_("Unable to connect to AMQP server"
 | 
			
		||||
                " after %d tries. Shutting down.") % FLAGS.rabbit_max_retries)
 | 
			
		||||
            sys.exit(1)
 | 
			
		||||
 | 
			
		||||
    def fetch(self, no_ack=None, auto_ack=None, enable_callbacks=False):
 | 
			
		||||
@@ -116,14 +116,14 @@ class Consumer(messaging.Consumer):
 | 
			
		||||
                self.declare()
 | 
			
		||||
            super(Consumer, self).fetch(no_ack, auto_ack, enable_callbacks)
 | 
			
		||||
            if self.failed_connection:
 | 
			
		||||
                logging.error("Reconnected to queue")
 | 
			
		||||
                logging.error(_("Reconnected to queue"))
 | 
			
		||||
                self.failed_connection = False
 | 
			
		||||
        # NOTE(vish): This is catching all errors because we really don't
 | 
			
		||||
        #             exceptions to be logged 10 times a second if some
 | 
			
		||||
        #             persistent failure occurs.
 | 
			
		||||
        except Exception:  # pylint: disable-msg=W0703
 | 
			
		||||
            if not self.failed_connection:
 | 
			
		||||
                logging.exception("Failed to fetch message from queue")
 | 
			
		||||
                logging.exception(_("Failed to fetch message from queue"))
 | 
			
		||||
                self.failed_connection = True
 | 
			
		||||
 | 
			
		||||
    def attach_to_eventlet(self):
 | 
			
		||||
@@ -161,7 +161,7 @@ class TopicConsumer(Consumer):
 | 
			
		||||
class AdapterConsumer(TopicConsumer):
 | 
			
		||||
    """Calls methods on a proxy object based on method and args"""
 | 
			
		||||
    def __init__(self, connection=None, topic="broadcast", proxy=None):
 | 
			
		||||
        LOG.debug('Initing the Adapter Consumer for %s' % (topic))
 | 
			
		||||
        LOG.debug(_('Initing the Adapter Consumer for %s') % (topic))
 | 
			
		||||
        self.proxy = proxy
 | 
			
		||||
        super(AdapterConsumer, self).__init__(connection=connection,
 | 
			
		||||
                                              topic=topic)
 | 
			
		||||
@@ -176,7 +176,7 @@ class AdapterConsumer(TopicConsumer):
 | 
			
		||||
 | 
			
		||||
        Example: {'method': 'echo', 'args': {'value': 42}}
 | 
			
		||||
        """
 | 
			
		||||
        LOG.debug('received %s' % (message_data))
 | 
			
		||||
        LOG.debug(_('received %s') % (message_data))
 | 
			
		||||
        msg_id = message_data.pop('_msg_id', None)
 | 
			
		||||
 | 
			
		||||
        ctxt = _unpack_context(message_data)
 | 
			
		||||
@@ -189,8 +189,8 @@ class AdapterConsumer(TopicConsumer):
 | 
			
		||||
            #             messages stay in the queue indefinitely, so for now
 | 
			
		||||
            #             we just log the message and send an error string
 | 
			
		||||
            #             back to the caller
 | 
			
		||||
            LOG.warn('no method for message: %s' % (message_data))
 | 
			
		||||
            msg_reply(msg_id, 'No method for message: %s' % message_data)
 | 
			
		||||
            LOG.warn(_('no method for message: %s') % (message_data))
 | 
			
		||||
            msg_reply(msg_id, _('No method for message: %s') % message_data)
 | 
			
		||||
            return
 | 
			
		||||
 | 
			
		||||
        node_func = getattr(self.proxy, str(method))
 | 
			
		||||
@@ -246,7 +246,7 @@ def msg_reply(msg_id, reply=None, failure=None):
 | 
			
		||||
    if failure:
 | 
			
		||||
        message = failure.getErrorMessage()
 | 
			
		||||
        traceback = failure.getTraceback()
 | 
			
		||||
        logging.error("Returning exception %s to caller", message)
 | 
			
		||||
        logging.error(_("Returning exception %s to caller"), message)
 | 
			
		||||
        logging.error(traceback)
 | 
			
		||||
        failure = (failure.type.__name__, str(failure.value), traceback)
 | 
			
		||||
    conn = Connection.instance()
 | 
			
		||||
@@ -287,7 +287,7 @@ def _unpack_context(msg):
 | 
			
		||||
        if key.startswith('_context_'):
 | 
			
		||||
            value = msg.pop(key)
 | 
			
		||||
            context_dict[key[9:]] = value
 | 
			
		||||
    LOG.debug('unpacked context: %s', context_dict)
 | 
			
		||||
    LOG.debug(_('unpacked context: %s'), context_dict)
 | 
			
		||||
    return context.RequestContext.from_dict(context_dict)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@@ -306,10 +306,10 @@ def _pack_context(msg, context):
 | 
			
		||||
 | 
			
		||||
def call(context, topic, msg):
 | 
			
		||||
    """Sends a message on a topic and wait for a response"""
 | 
			
		||||
    LOG.debug("Making asynchronous call...")
 | 
			
		||||
    LOG.debug(_("Making asynchronous call..."))
 | 
			
		||||
    msg_id = uuid.uuid4().hex
 | 
			
		||||
    msg.update({'_msg_id': msg_id})
 | 
			
		||||
    LOG.debug("MSG_ID is %s" % (msg_id))
 | 
			
		||||
    LOG.debug(_("MSG_ID is %s") % (msg_id))
 | 
			
		||||
    _pack_context(msg, context)
 | 
			
		||||
 | 
			
		||||
    class WaitMessage(object):
 | 
			
		||||
@@ -345,7 +345,7 @@ def call_twisted(context, topic, msg):
 | 
			
		||||
    LOG.debug("Making asynchronous call...")
 | 
			
		||||
    msg_id = uuid.uuid4().hex
 | 
			
		||||
    msg.update({'_msg_id': msg_id})
 | 
			
		||||
    LOG.debug("MSG_ID is %s" % (msg_id))
 | 
			
		||||
    LOG.debug(_("MSG_ID is %s") % (msg_id))
 | 
			
		||||
    _pack_context(msg, context)
 | 
			
		||||
 | 
			
		||||
    conn = Connection.instance()
 | 
			
		||||
@@ -384,7 +384,7 @@ def cast(context, topic, msg):
 | 
			
		||||
 | 
			
		||||
def generic_response(message_data, message):
 | 
			
		||||
    """Logs a result and exits"""
 | 
			
		||||
    LOG.debug('response %s', message_data)
 | 
			
		||||
    LOG.debug(_('response %s'), message_data)
 | 
			
		||||
    message.ack()
 | 
			
		||||
    sys.exit(0)
 | 
			
		||||
 | 
			
		||||
@@ -393,8 +393,8 @@ def send_message(topic, message, wait=True):
 | 
			
		||||
    """Sends a message for testing"""
 | 
			
		||||
    msg_id = uuid.uuid4().hex
 | 
			
		||||
    message.update({'_msg_id': msg_id})
 | 
			
		||||
    LOG.debug('topic is %s', topic)
 | 
			
		||||
    LOG.debug('message %s', message)
 | 
			
		||||
    LOG.debug(_('topic is %s'), topic)
 | 
			
		||||
    LOG.debug(_('message %s'), message)
 | 
			
		||||
 | 
			
		||||
    if wait:
 | 
			
		||||
        consumer = messaging.Consumer(connection=Connection.instance(),
 | 
			
		||||
 
 | 
			
		||||
@@ -34,5 +34,5 @@ class ChanceScheduler(driver.Scheduler):
 | 
			
		||||
 | 
			
		||||
        hosts = self.hosts_up(context, topic)
 | 
			
		||||
        if not hosts:
 | 
			
		||||
            raise driver.NoValidHost("No hosts found")
 | 
			
		||||
            raise driver.NoValidHost(_("No hosts found"))
 | 
			
		||||
        return hosts[int(random.random() * len(hosts))]
 | 
			
		||||
 
 | 
			
		||||
@@ -58,4 +58,4 @@ class Scheduler(object):
 | 
			
		||||
 | 
			
		||||
    def schedule(self, context, topic, *_args, **_kwargs):
 | 
			
		||||
        """Must override at least this method for scheduler to work."""
 | 
			
		||||
        raise NotImplementedError("Must implement a fallback schedule")
 | 
			
		||||
        raise NotImplementedError(_("Must implement a fallback schedule"))
 | 
			
		||||
 
 | 
			
		||||
@@ -65,4 +65,4 @@ class SchedulerManager(manager.Manager):
 | 
			
		||||
                 db.queue_get_for(context, topic, host),
 | 
			
		||||
                 {"method": method,
 | 
			
		||||
                  "args": kwargs})
 | 
			
		||||
        logging.debug("Casting to %s %s for %s", topic, host, method)
 | 
			
		||||
        logging.debug(_("Casting to %s %s for %s"), topic, host, method)
 | 
			
		||||
 
 | 
			
		||||
@@ -47,7 +47,7 @@ class SimpleScheduler(chance.ChanceScheduler):
 | 
			
		||||
        for result in results:
 | 
			
		||||
            (service, instance_cores) = result
 | 
			
		||||
            if instance_cores + instance_ref['vcpus'] > FLAGS.max_cores:
 | 
			
		||||
                raise driver.NoValidHost("All hosts have too many cores")
 | 
			
		||||
                raise driver.NoValidHost(_("All hosts have too many cores"))
 | 
			
		||||
            if self.service_is_up(service):
 | 
			
		||||
                # NOTE(vish): this probably belongs in the manager, if we
 | 
			
		||||
                #             can generalize this somehow
 | 
			
		||||
@@ -57,7 +57,7 @@ class SimpleScheduler(chance.ChanceScheduler):
 | 
			
		||||
                                   {'host': service['host'],
 | 
			
		||||
                                    'scheduled_at': now})
 | 
			
		||||
                return service['host']
 | 
			
		||||
        raise driver.NoValidHost("No hosts found")
 | 
			
		||||
        raise driver.NoValidHost(_("No hosts found"))
 | 
			
		||||
 | 
			
		||||
    def schedule_create_volume(self, context, volume_id, *_args, **_kwargs):
 | 
			
		||||
        """Picks a host that is up and has the fewest volumes."""
 | 
			
		||||
@@ -66,7 +66,8 @@ class SimpleScheduler(chance.ChanceScheduler):
 | 
			
		||||
        for result in results:
 | 
			
		||||
            (service, volume_gigabytes) = result
 | 
			
		||||
            if volume_gigabytes + volume_ref['size'] > FLAGS.max_gigabytes:
 | 
			
		||||
                raise driver.NoValidHost("All hosts have too many gigabytes")
 | 
			
		||||
                raise driver.NoValidHost(_("All hosts have too many "
 | 
			
		||||
                                           "gigabytes"))
 | 
			
		||||
            if self.service_is_up(service):
 | 
			
		||||
                # NOTE(vish): this probably belongs in the manager, if we
 | 
			
		||||
                #             can generalize this somehow
 | 
			
		||||
@@ -76,7 +77,7 @@ class SimpleScheduler(chance.ChanceScheduler):
 | 
			
		||||
                                 {'host': service['host'],
 | 
			
		||||
                                  'scheduled_at': now})
 | 
			
		||||
                return service['host']
 | 
			
		||||
        raise driver.NoValidHost("No hosts found")
 | 
			
		||||
        raise driver.NoValidHost(_("No hosts found"))
 | 
			
		||||
 | 
			
		||||
    def schedule_set_network_host(self, context, *_args, **_kwargs):
 | 
			
		||||
        """Picks a host that is up and has the fewest networks."""
 | 
			
		||||
@@ -85,7 +86,7 @@ class SimpleScheduler(chance.ChanceScheduler):
 | 
			
		||||
        for result in results:
 | 
			
		||||
            (service, instance_count) = result
 | 
			
		||||
            if instance_count >= FLAGS.max_networks:
 | 
			
		||||
                raise driver.NoValidHost("All hosts have too many networks")
 | 
			
		||||
                raise driver.NoValidHost(_("All hosts have too many networks"))
 | 
			
		||||
            if self.service_is_up(service):
 | 
			
		||||
                return service['host']
 | 
			
		||||
        raise driver.NoValidHost("No hosts found")
 | 
			
		||||
        raise driver.NoValidHost(_("No hosts found"))
 | 
			
		||||
 
 | 
			
		||||
@@ -58,7 +58,7 @@ def stop(pidfile):
 | 
			
		||||
    try:
 | 
			
		||||
        pid = int(open(pidfile, 'r').read().strip())
 | 
			
		||||
    except IOError:
 | 
			
		||||
        message = "pidfile %s does not exist. Daemon not running?\n"
 | 
			
		||||
        message = _("pidfile %s does not exist. Daemon not running?\n")
 | 
			
		||||
        sys.stderr.write(message % pidfile)
 | 
			
		||||
        return
 | 
			
		||||
 | 
			
		||||
@@ -84,7 +84,7 @@ def serve(name, main):
 | 
			
		||||
    if not FLAGS.pidfile:
 | 
			
		||||
        FLAGS.pidfile = '%s.pid' % name
 | 
			
		||||
 | 
			
		||||
    logging.debug("Full set of FLAGS: \n\n\n")
 | 
			
		||||
    logging.debug(_("Full set of FLAGS: \n\n\n"))
 | 
			
		||||
    for flag in FLAGS:
 | 
			
		||||
        logging.debug("%s : %s", flag, FLAGS.get(flag, None))
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -143,7 +143,7 @@ class Service(object, service.Service):
 | 
			
		||||
            report_interval = FLAGS.report_interval
 | 
			
		||||
        if not periodic_interval:
 | 
			
		||||
            periodic_interval = FLAGS.periodic_interval
 | 
			
		||||
        logging.warn("Starting %s node", topic)
 | 
			
		||||
        logging.warn(_("Starting %s node"), topic)
 | 
			
		||||
        service_obj = cls(host, binary, topic, manager,
 | 
			
		||||
                          report_interval, periodic_interval)
 | 
			
		||||
 | 
			
		||||
@@ -158,7 +158,7 @@ class Service(object, service.Service):
 | 
			
		||||
        try:
 | 
			
		||||
            db.service_destroy(context.get_admin_context(), self.service_id)
 | 
			
		||||
        except exception.NotFound:
 | 
			
		||||
            logging.warn("Service killed that has no database entry")
 | 
			
		||||
            logging.warn(_("Service killed that has no database entry"))
 | 
			
		||||
 | 
			
		||||
    @defer.inlineCallbacks
 | 
			
		||||
    def periodic_tasks(self):
 | 
			
		||||
@@ -173,8 +173,8 @@ class Service(object, service.Service):
 | 
			
		||||
            try:
 | 
			
		||||
                service_ref = db.service_get(ctxt, self.service_id)
 | 
			
		||||
            except exception.NotFound:
 | 
			
		||||
                logging.debug("The service database object disappeared, "
 | 
			
		||||
                              "Recreating it.")
 | 
			
		||||
                logging.debug(_("The service database object disappeared, "
 | 
			
		||||
                              "Recreating it."))
 | 
			
		||||
                self._create_service_ref(ctxt)
 | 
			
		||||
                service_ref = db.service_get(ctxt, self.service_id)
 | 
			
		||||
 | 
			
		||||
@@ -185,11 +185,11 @@ class Service(object, service.Service):
 | 
			
		||||
            # TODO(termie): make this pattern be more elegant.
 | 
			
		||||
            if getattr(self, "model_disconnected", False):
 | 
			
		||||
                self.model_disconnected = False
 | 
			
		||||
                logging.error("Recovered model server connection!")
 | 
			
		||||
                logging.error(_("Recovered model server connection!"))
 | 
			
		||||
 | 
			
		||||
        # TODO(vish): this should probably only catch connection errors
 | 
			
		||||
        except Exception:  # pylint: disable-msg=W0702
 | 
			
		||||
            if not getattr(self, "model_disconnected", False):
 | 
			
		||||
                self.model_disconnected = True
 | 
			
		||||
                logging.exception("model server went away")
 | 
			
		||||
                logging.exception(_("model server went away"))
 | 
			
		||||
        yield
 | 
			
		||||
 
 | 
			
		||||
@@ -208,7 +208,7 @@ def stop(pidfile):
 | 
			
		||||
        pid = None
 | 
			
		||||
 | 
			
		||||
    if not pid:
 | 
			
		||||
        message = "pidfile %s does not exist. Daemon not running?\n"
 | 
			
		||||
        message = _("pidfile %s does not exist. Daemon not running?\n")
 | 
			
		||||
        sys.stderr.write(message % pidfile)
 | 
			
		||||
        # Not an error in a restart
 | 
			
		||||
        return
 | 
			
		||||
@@ -229,7 +229,7 @@ def stop(pidfile):
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def serve(filename):
 | 
			
		||||
    logging.debug("Serving %s" % filename)
 | 
			
		||||
    logging.debug(_("Serving %s") % filename)
 | 
			
		||||
    name = os.path.basename(filename)
 | 
			
		||||
    OptionsClass = WrapTwistedOptions(TwistdServerOptions)
 | 
			
		||||
    options = OptionsClass()
 | 
			
		||||
@@ -281,7 +281,7 @@ def serve(filename):
 | 
			
		||||
    else:
 | 
			
		||||
        logging.getLogger().setLevel(logging.WARNING)
 | 
			
		||||
 | 
			
		||||
    logging.debug("Full set of FLAGS:")
 | 
			
		||||
    logging.debug(_("Full set of FLAGS:"))
 | 
			
		||||
    for flag in FLAGS:
 | 
			
		||||
        logging.debug("%s : %s" % (flag, FLAGS.get(flag, None)))
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -49,7 +49,7 @@ def import_class(import_str):
 | 
			
		||||
        __import__(mod_str)
 | 
			
		||||
        return getattr(sys.modules[mod_str], class_str)
 | 
			
		||||
    except (ImportError, ValueError, AttributeError):
 | 
			
		||||
        raise exception.NotFound('Class %s cannot be found' % class_str)
 | 
			
		||||
        raise exception.NotFound(_('Class %s cannot be found') % class_str)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def import_object(import_str):
 | 
			
		||||
@@ -63,7 +63,7 @@ def import_object(import_str):
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def fetchfile(url, target):
 | 
			
		||||
    logging.debug("Fetching %s" % url)
 | 
			
		||||
    logging.debug(_("Fetching %s") % url)
 | 
			
		||||
#    c = pycurl.Curl()
 | 
			
		||||
#    fp = open(target, "wb")
 | 
			
		||||
#    c.setopt(c.URL, url)
 | 
			
		||||
@@ -75,7 +75,7 @@ def fetchfile(url, target):
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def execute(cmd, process_input=None, addl_env=None, check_exit_code=True):
 | 
			
		||||
    logging.debug("Running cmd: %s", cmd)
 | 
			
		||||
    logging.debug(_("Running cmd: %s"), cmd)
 | 
			
		||||
    env = os.environ.copy()
 | 
			
		||||
    if addl_env:
 | 
			
		||||
        env.update(addl_env)
 | 
			
		||||
@@ -88,7 +88,7 @@ def execute(cmd, process_input=None, addl_env=None, check_exit_code=True):
 | 
			
		||||
        result = obj.communicate()
 | 
			
		||||
    obj.stdin.close()
 | 
			
		||||
    if obj.returncode:
 | 
			
		||||
        logging.debug("Result was %s" % (obj.returncode))
 | 
			
		||||
        logging.debug(_("Result was %s") % (obj.returncode))
 | 
			
		||||
        if check_exit_code and obj.returncode != 0:
 | 
			
		||||
            (stdout, stderr) = result
 | 
			
		||||
            raise ProcessExecutionError(exit_code=obj.returncode,
 | 
			
		||||
@@ -122,7 +122,7 @@ def debug(arg):
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def runthis(prompt, cmd, check_exit_code=True):
 | 
			
		||||
    logging.debug("Running %s" % (cmd))
 | 
			
		||||
    logging.debug(_("Running %s") % (cmd))
 | 
			
		||||
    exit_code = subprocess.call(cmd.split(" "))
 | 
			
		||||
    logging.debug(prompt % (exit_code))
 | 
			
		||||
    if check_exit_code and exit_code != 0:
 | 
			
		||||
@@ -161,7 +161,7 @@ def get_my_ip():
 | 
			
		||||
        csock.close()
 | 
			
		||||
        return addr
 | 
			
		||||
    except socket.gaierror as ex:
 | 
			
		||||
        logging.warn("Couldn't get IP, using 127.0.0.1 %s", ex)
 | 
			
		||||
        logging.warn(_("Couldn't get IP, using 127.0.0.1 %s"), ex)
 | 
			
		||||
        return "127.0.0.1"
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@@ -205,7 +205,7 @@ class LazyPluggable(object):
 | 
			
		||||
        if not self.__backend:
 | 
			
		||||
            backend_name = self.__pivot.value
 | 
			
		||||
            if backend_name not in self.__backends:
 | 
			
		||||
                raise exception.Error('Invalid backend: %s' % backend_name)
 | 
			
		||||
                raise exception.Error(_('Invalid backend: %s') % backend_name)
 | 
			
		||||
 | 
			
		||||
            backend = self.__backends[backend_name]
 | 
			
		||||
            if type(backend) == type(tuple()):
 | 
			
		||||
 
 | 
			
		||||
@@ -42,7 +42,7 @@ def rangetest(**argchecks):
 | 
			
		||||
                    # was passed by name
 | 
			
		||||
                    if float(kargs[argname]) < low or \
 | 
			
		||||
                       float(kargs[argname]) > high:
 | 
			
		||||
                        errmsg = '{0} argument "{1}" not in {2}..{3}'
 | 
			
		||||
                        errmsg = _('{0} argument "{1}" not in {2}..{3}')
 | 
			
		||||
                        errmsg = errmsg.format(funcname, argname, low, high)
 | 
			
		||||
                        raise TypeError(errmsg)
 | 
			
		||||
 | 
			
		||||
@@ -51,8 +51,8 @@ def rangetest(**argchecks):
 | 
			
		||||
                    position = positionals.index(argname)
 | 
			
		||||
                    if float(pargs[position]) < low or \
 | 
			
		||||
                       float(pargs[position]) > high:
 | 
			
		||||
                        errmsg = '{0} argument "{1}" with value of {4} ' \
 | 
			
		||||
                                 'not in {2}..{3}'
 | 
			
		||||
                        errmsg = _('{0} argument "{1}" with value of {4} '
 | 
			
		||||
                                   'not in {2}..{3}')
 | 
			
		||||
                        errmsg = errmsg.format(funcname, argname, low, high,
 | 
			
		||||
                                               pargs[position])
 | 
			
		||||
                        raise TypeError(errmsg)
 | 
			
		||||
@@ -76,14 +76,14 @@ def typetest(**argchecks):
 | 
			
		||||
            for (argname, typeof) in argchecks.items():
 | 
			
		||||
                if argname in kargs:
 | 
			
		||||
                    if not isinstance(kargs[argname], typeof):
 | 
			
		||||
                        errmsg = '{0} argument "{1}" not of type {2}'
 | 
			
		||||
                        errmsg = _('{0} argument "{1}" not of type {2}')
 | 
			
		||||
                        errmsg = errmsg.format(funcname, argname, typeof)
 | 
			
		||||
                        raise TypeError(errmsg)
 | 
			
		||||
                elif argname in positionals:
 | 
			
		||||
                    position = positionals.index(argname)
 | 
			
		||||
                    if not isinstance(pargs[position], typeof):
 | 
			
		||||
                        errmsg = '{0} argument "{1}" with value of {2} ' \
 | 
			
		||||
                                 'not of type {3}'
 | 
			
		||||
                        errmsg = _('{0} argument "{1}" with value of {2} '
 | 
			
		||||
                                   'not of type {3}')
 | 
			
		||||
                        errmsg = errmsg.format(funcname, argname,
 | 
			
		||||
                                               pargs[position], typeof)
 | 
			
		||||
                        raise TypeError(errmsg)
 | 
			
		||||
 
 | 
			
		||||
		Reference in New Issue
	
	Block a user