← Back to branch summary

~certify-web-dev/twisted/certify-trunk

« back to all changes in this revision

Viewing changes to twisted/python/failure.py

  • Committer: Bazaar Package Importer
  • Author(s): Moshe Zadka
  • Date: 2002-03-08 07:14:16 UTC
  • Revision ID: james.westby@ubuntu.com-20020308071416-oxvuw76tpcpi5v1q
Tags: upstream-0.15.5
Import upstream version 0.15.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
twisted/python/failure.py
 
1
 
 
2
 
 
3
# System Imports
 
4
import sys
 
5
import traceback
 
6
import linecache
 
7
import string
 
8
from cStringIO import StringIO
 
9
 
 
10
count = 0
 
11
 
 
12
class Failure:
 
13
    """A basic abstraction for an error that has occurred.
 
14
 
 
15
    This is necessary because Python's built-in error mechanisms are
 
16
    inconvenient for asynchronous communication.
 
17
    """
 
18
 
 
19
    pickled = 0
 
20
 
 
21
    def __init__(self, exc_value=None, exc_type=None, exc_tb=None):
 
22
        """Initialize me with an explanation of the error.
 
23
 
 
24
        By default, this will use the current exception (sys.exc_info()).
 
25
        However, if you want to specify a particular kind of failure, you can
 
26
        pass an exception as an argument.
 
27
        """
 
28
        global count
 
29
        count = count + 1
 
30
        self.count = count
 
31
        self.type, self.value, tb = None, None, None
 
32
        if exc_value is None:
 
33
            self.type, self.value, tb = sys.exc_info()
 
34
        elif exc_type is None:
 
35
            self.type = exc_value.__class__
 
36
            self.value = exc_value
 
37
        else:
 
38
            self.type = exc_type
 
39
            self.value = exc_value
 
40
        frames = self.frames = []
 
41
        while tb is not None:
 
42
            f = tb.tb_frame
 
43
            localz = f.f_locals.copy()
 
44
            if f.f_locals is f.f_globals:
 
45
                globalz = {}
 
46
            else:
 
47
                globalz = f.f_globals.copy()
 
48
            frames.append([
 
49
                f.f_code.co_name,
 
50
                f.f_code.co_filename,
 
51
                tb.tb_lineno,
 
52
                localz.items(),
 
53
                globalz.items(),
 
54
                ])
 
55
            tb = tb.tb_next
 
56
 
 
57
    def getErrorMessage(self):
 
58
        if isinstance(self.value, Failure):
 
59
            return self.value.getErrorMessage()
 
60
        return str(self.value)
 
61
 
 
62
    def trap(self, *errorTypes):
 
63
        """Trap this failure if its type is in a predetermined list.
 
64
 
 
65
        This allows you to trap a Failure in an error callback.  It will be
 
66
        automatically re-raised if it is not a type that you expect.
 
67
        """
 
68
        for errorType in errorTypes:
 
69
            if (self.type == errorType or
 
70
                issubclass(self.type, errorType)):
 
71
                break
 
72
        else:
 
73
            raise self
 
74
 
 
75
    def getBriefTraceback(self):
 
76
        io = StringIO()
 
77
        self.printBriefTraceback(file=io)
 
78
        return io.getvalue()
 
79
 
 
80
    def __repr__(self):
 
81
        return "[Failure instance: %s]" % self.getBriefTraceback()
 
82
 
 
83
    def __getstate__(self):
 
84
        """Avoid pickling objects in the traceback.
 
85
        """
 
86
        c = self.__dict__.copy()
 
87
        frames = c['frames'] = []
 
88
        stringize = lambda (x, y): (x, repr(y))
 
89
        for m, f, l, lo, gl in self.frames:
 
90
            frames.append([m, f, l, map(stringize, lo), map(stringize, gl)])
 
91
        c['pickled'] = 1
 
92
        return c
 
93
 
 
94
    def printTraceback(self, file=None):
 
95
        """Emulate Python's standard error reporting mechanism.
 
96
        """
 
97
        if file is None: file = sys.stdout
 
98
        w = file.write
 
99
        w( 'Traceback (most recent call last):\n')
 
100
        for method, filename, lineno, localVars, globalVars in self.frames:
 
101
            w( '  File "%s", line %s, in %s\n' % (filename, lineno, method))
 
102
            w( '    %s\n' % string.strip(linecache.getline(filename, lineno)))
 
103
            # w( '\n')
 
104
        w("%s: %s\n" % (str(self.type), str(self.value)))
 
105
        if isinstance(self.value, Failure):
 
106
            file.write(" (chained Failure)\n")
 
107
            self.value.printTraceback(file)
 
108
 
 
109
    def printBriefTraceback(self, file=None):
 
110
        """Print a traceback as densely as possible.
 
111
        """
 
112
        if file is None: file = sys.stdout
 
113
        w = file.write
 
114
        w("Traceback! %s, %s\n" % (self.type, self.value))
 
115
        for method, filename, lineno, localVars, globalVars in self.frames:
 
116
            w('%s:%s:%s\n' % (filename, lineno, method))
 
117
        if isinstance(self.value, Failure):
 
118
            file.write(" (chained Failure)\n")
 
119
            self.value.printBriefTraceback(file)
 
120
 
 
121
    def printDetailedTraceback(self, file=None):
 
122
        """Print a traceback with detailed locals and globals information.
 
123
        """
 
124
        if file is None: file = sys.stdout
 
125
        w = file.write
 
126
        w( '*--- Failure #%d%s---\n' %
 
127
           (self.count,
 
128
            (self.pickled and ' (pickled) ') or ' '))
 
129
        for method, filename, lineno, localVars, globalVars in self.frames:
 
130
            w("%s:%d: %s(...)\n" % (filename, lineno, method))
 
131
            w(' [ Locals ]\n')
 
132
            for name, val in localVars:
 
133
                w("  %s : %s\n" %  (name,(self.pickled and val) or repr(val)))
 
134
            w(' ( Globals )\n')
 
135
            for name, val in globalVars:
 
136
                w("  %s : %s\n" %  (name,(self.pickled and val) or repr(val)))
 
137
        if isinstance(self.value, Failure):
 
138
            w(" (chained Failure)\n")
 
139
            self.value.printDetailedTraceback(file)
 
140
        w('*--- End of Failure #%d ---\n' % self.count)