Пример #1
0
 def raiseError(self, err):
     info = err.args[0]
     message = toUnicode(info['desc'])
     if 'info' in info:
         message += u"; %s" % toUnicode(info['info'])
     if 'matched' in info:
         matched = toUnicode(info['matched'])
         message += u" (%s)" % matched
     raise RulesetError(tr("LDAP error: %s"), message)
Пример #2
0
 def create(self, conf, logger):
     dbtype = conf['dbtype']
     try:
         db_object = self.objects[dbtype]
         if isinstance(db_object, (str, unicode)):
             raise DatabaseError(tr('Unable to use %s: %s'), dbtype, toUnicode(db_object))
     except KeyError, e:
         raise DatabaseError(tr('Unsupported database type %s'), dbtype)
Пример #3
0
def exceptionAsUnicode(err, add_type=True):
    r"""
    add_type option changes the output for KeyError and exception with an empty
    message (eg. AssertionError). If the option is True (default): add the type
    as prefix, otherwise return an empty string.

    >>> exceptionAsUnicode(Exception("ascii"))
    u'ascii'
    >>> exceptionAsUnicode(Exception("h\xe9 h\xe9"))
    u'h\xe9 h\xe9'
    >>> exceptionAsUnicode(UnicodeException(u"h\xe9 h\xe9"))
    u'h\xe9 h\xe9'
    >>> exceptionAsUnicode(AssertionError())
    u'[AssertionError]'
    >>> exceptionAsUnicode(KeyError(3))
    u'[KeyError] 3'
    >>> exceptionAsUnicode(KeyError(3), False)
    u'3'
    """
    if isinstance(err, (IOError, OSError)) and err.strerror:
        # Get "message" instead of "(42, 'message')"
        return toUnicode(err.strerror)
    if isinstance(err, socket_error):
        # Get 'Connexion refus\xc3\xa9e' instead of
        # (111, 'Connexion refus\xc3\xa9e')
        args = err.args
        if 2 <= len(args):
            msg = args[1]
        else:
            msg = args[0]
        return toUnicode(msg)
    try:
        text = unicode(err)
    except (UnicodeDecodeError, UnicodeEncodeError):
        as_bytes = str(err)
        text = toUnicode(as_bytes)
    if add_type:
        if isinstance(err, KeyError):
            # KeyError message is the key, which is usually meaningless:
            # add [KeyError] prefix
            text = u"[%s] %s" % (err.__class__.__name__, text)
        elif not text:
            # Some errors (eg. AssertionError) have no text, so display the
            # exception type instead of an empty string
            text = u"[%s]" % err.__class__.__name__
    return text
Пример #4
0
 def _parseGroup(self):
     groups = set()
     with open('/etc/group') as fp:
         for line in fp.readlines():
             line = line.rstrip()
             name = line.split(':')[0]
             name = toUnicode(name)
             groups.add(name)
     return groups
Пример #5
0
def formatTraceback(traceback):
    if not isinstance(traceback, str):
        traceback = format_exception(*traceback)
        if traceback == ["None\n"]:
            return None

        traceback = ''.join(traceback)
    traceback = traceback.rstrip()
    lines = traceback.splitlines()
    return [toUnicode(line) for line in lines]
Пример #6
0
    def __init__(self, *arguments, **keywords):
        if isinstance(arguments[0], (str, unicode)):
            # Old API: raise UnicodeException("error: %s", err)
#            deprecationWarning(
#                "UnicodeException(format, arguments): "
#                "missing application, component and error code",
#                3)
            self.application = 0
            self.component = 0
            self.error_code = 0
            message = arguments[0]
            arguments = arguments[1:]
        else:
            # New API: UnicodeException(app, component, ...)
            self.application = arguments[0]
            self.component = arguments[1]
            if isinstance(arguments[2], (str, unicode)):
                # UnicodeException(app, component, "format", ...): missing code
#                deprecationWarning(
#                    "UnicodeException(application, component, format, arguments): "
#                    "missing error code",
#                    4)
                self.error_code = 0
                message = arguments[2]
                arguments = arguments[3:]
            else:
                # UnicodeException(app, component, errcode, "format", ...): correct
                self.error_code = arguments[2]
                message = arguments[3]
                arguments = arguments[4:]

        self.additionals = []

        # Check arguments / keywords
        if arguments and keywords:
            self.additionals.append(
                u"You can not use arguments *and* keywords with UnicodeException!")
            arguments = None
            keywords = None

        # Convert message to Unicode
        self.unicode_message = toUnicode(message)
        self.format = self.unicode_message

        # Make sure that arguments are serialisable, if no convert them to
        # serialisable type
        if keywords:
            for key, value in keywords.iteritems():
                try:
                    checkSimpleType(value)
                except TransportError, err:
                    keywords[key] = self.formatArgument(value)
                    self.additionals.append(
                        u"The keyword argument %r is unserializable: %s"
                        % (key, err))
Пример #7
0
 def resolveHostname(self):
     if self.address_type == IPV6_ADDRESS:
         family = AF_INET6
     else:
         family = AF_INET
     addresses = set()
     try:
         for family, socktype, proto, canonname, sockaddr in getaddrinfo(self.hostname, None, family):
             address = parseIPAddress(sockaddr[0])
             addresses.add(address)
     except gaierror, err:
         message = toUnicode(err.args[1])
         raise RulesetError(tr('Unable to get the address of the hostname "%s": %s!'), self.hostname, message)
Пример #8
0
 def __init__(self, type, message, traceback=None, err_id=None):
     """id : (application, component, code)"""
     if message:
         message = toUnicode(message)
     else:
         message = u"[%s]" % type
     UnicodeException.__init__(self, message)
     self.type = type
     self.traceback = traceback
     if err_id:
         self.id = err_id
     else:
         self.id = (None, None, None)
     self.application, self.component, self.code = self.id
Пример #9
0
    def success_download(self, value):
        self._stop_splash()
        encoded, components = value
        self.mainwindow.addToInfoArea(tr("Downloaded EdenWall configuration"))

        extension = "*.tar.gz"
        archive_description = tr("Edenwall archive file")
        filter = "%s (%s)" % (archive_description, extension)

        date = datetime.now().strftime("%c")
        date = toUnicode(date)
        date = date.replace(".", "")
        date = date.replace(" ", "_")
        date = date.replace(":", "-")

        host = self.mainwindow.client.host
        host = host.replace(".", "_")
        host = host.replace(":", "-")
        suggestion = u"edenwall-config-%s-%s.tar.gz" % (host, date)

        filename = QFileDialog.getSaveFileName(
            self, tr("Choose a filename to save under"), join(SaveRestoreWidget.last_save_position, suggestion), filter
        )

        filename = unicode(filename)

        if not filename:
            self.mainwindow.addToInfoArea(tr("EdenWall configuration save cancelled"))
            return

        SaveRestoreWidget.last_save_position = split(filename)[0]

        try:
            with open(filename, "wb") as fd:
                fd.write(decodeFileContent(encoded))
        except IOError, err:
            message_vars = (tr("An error occured while saving EdenWall configuration:"), toUnicode(strerror(err.errno)))

            text_message = "%s\n%s" % message_vars
            self.mainwindow.addToInfoArea(text_message, category=COLOR_ERROR)

            html_message = "<span>%s<br/><b>%s</b></span>" % message_vars
            QMessageBox.critical(self, tr("Save error"), html_message)
            return
Пример #10
0
    def formatArgument(self, value):
        # Try as unicode characters
        try:
            text = unicode(value)
            checkSimpleType(text)
            return text
        except (UnicodeError, TransportError):
            pass

        # Try as byte string and then reconvert to Unicode
        try:
            text = str(value)
            text = toUnicode(text)
            checkSimpleType(text)
            return text
        except TransportError:
            pass

        # Last chance: replace the value
        return u"[ERROR]"
Пример #11
0
def getIP(addr, address_type):
    try:
        addr = IP(addr)
    except ValueError:
        pass
    else:
        return set((addr,))

    if address_type == IPV6_ADDRESS:
        family = AF_INET6
    else:
        family = AF_INET

    addresses = set()
    try:
        for family2, socktype, proto, canonname, sockaddr \
        in getaddrinfo(addr, None, family):
            address = IP(unicode(sockaddr[0]))
            addresses.add(address)
    except gaierror, gai_err:
        raise LocalFWError(
            tr('Unable to get the "%s" host address: %s'),
            unicode(addr), toUnicode(gai_err.args[1]))
Пример #12
0
 def __init__(self, message):
     self.unicode_message = toUnicode(message)
     bytes_message = self.unicode_message.encode("ASCII", "replace")
     Exception.__init__(self, bytes_message)
Пример #13
0
 def setUsePKI(self, value):
     if value:
         self.use_pki = toUnicode(value)
     else:
         self.use_pki = u''