← Back to branch summary

~ntt-pf-lab/nova/monkey_patch_notification

« back to all changes in this revision

Viewing changes to vendor/Twisted-10.0.0/twisted/manhole/_inspectro.py

  • Committer: Jesse Andrews
  • Date: 2010-05-28 06:05:26 UTC
  • Revision ID: git-v1:bf6e6e718cdc7488e2da87b21e258ccc065fe499
initial commit

Show diffs side-by-side

added added

removed removed

Lines of Context:
vendor/Twisted-10.0.0/twisted/manhole/_inspectro.py
 
1
# Copyright (c) 2001-2004 Twisted Matrix Laboratories.
 
2
# See LICENSE for details.
 
3
 
 
4
 
 
5
"""An input/output window for the glade reactor inspector.
 
6
"""
 
7
 
 
8
import time
 
9
import gtk
 
10
import gobject
 
11
import gtk.glade
 
12
from twisted.python.util import sibpath
 
13
from twisted.python import reflect
 
14
 
 
15
from twisted.manhole.ui import gtk2manhole
 
16
from twisted.python.components import Adapter, registerAdapter
 
17
from twisted.python import log
 
18
from twisted.protocols import policies
 
19
from zope.interface import implements, Interface
 
20
 
 
21
# the glade file uses stock icons, which requires gnome to be installed
 
22
import gnome
 
23
version = "$Revision: 1.1 $"[11:-2]
 
24
gnome.init("gladereactor Inspector", version)
 
25
 
 
26
class ConsoleOutput(gtk2manhole.ConsoleOutput):
 
27
    def _captureLocalLog(self):
 
28
        self.fobs = log.FileLogObserver(gtk2manhole._Notafile(self, "log"))
 
29
        self.fobs.start()
 
30
 
 
31
    def stop(self):
 
32
        self.fobs.stop()
 
33
        del self.fobs
 
34
 
 
35
class ConsoleInput(gtk2manhole.ConsoleInput):
 
36
    def sendMessage(self):
 
37
        buffer = self.textView.get_buffer()
 
38
        iter1, iter2 = buffer.get_bounds()
 
39
        text = buffer.get_text(iter1, iter2, False)
 
40
        self.do(text)
 
41
 
 
42
    def do(self, text):
 
43
        self.toplevel.do(text)
 
44
 
 
45
class INode(Interface):
 
46
    """A node in the inspector tree model.
 
47
    """
 
48
 
 
49
    def __adapt__(adaptable, default):
 
50
        if hasattr(adaptable, "__dict__"):
 
51
            return InstanceNode(adaptable)
 
52
        return AttributesNode(adaptable)
 
53
 
 
54
class InspectorNode(Adapter):
 
55
    implements(INode)
 
56
 
 
57
    def postInit(self, offset, parent, slot):
 
58
        self.offset = offset
 
59
        self.parent = parent
 
60
        self.slot = slot
 
61
 
 
62
    def getPath(self):
 
63
        L = []
 
64
        x = self
 
65
        while x.parent is not None:
 
66
            L.append(x.offset)
 
67
            x = x.parent
 
68
        L.reverse()
 
69
        return L
 
70
 
 
71
    def __getitem__(self, index):
 
72
        slot, o = self.get(index)
 
73
        n = INode(o, persist=False)
 
74
        n.postInit(index, self, slot)
 
75
        return n
 
76
 
 
77
    def origstr(self):
 
78
        return str(self.original)
 
79
 
 
80
    def format(self):
 
81
        return (self.slot, self.origstr())
 
82
 
 
83
 
 
84
class ConstantNode(InspectorNode):
 
85
    def __len__(self):
 
86
        return 0
 
87
 
 
88
class DictionaryNode(InspectorNode):
 
89
    def get(self, index):
 
90
        L = self.original.items()
 
91
        L.sort()
 
92
        return L[index]
 
93
 
 
94
    def __len__(self):
 
95
        return len(self.original)
 
96
 
 
97
    def origstr(self):
 
98
        return "Dictionary"
 
99
 
 
100
class ListNode(InspectorNode):
 
101
    def get(self, index):
 
102
        return index, self.original[index]
 
103
 
 
104
    def origstr(self):
 
105
        return "List"
 
106
 
 
107
    def __len__(self):
 
108
        return len(self.original)
 
109
 
 
110
class AttributesNode(InspectorNode):
 
111
    def __len__(self):
 
112
        return len(dir(self.original))
 
113
 
 
114
    def get(self, index):
 
115
        L = dir(self.original)
 
116
        L.sort()
 
117
        return L[index], getattr(self.original, L[index])
 
118
 
 
119
class InstanceNode(InspectorNode):
 
120
    def __len__(self):
 
121
        return len(self.original.__dict__) + 1
 
122
 
 
123
    def get(self, index):
 
124
        if index == 0:
 
125
            if hasattr(self.original, "__class__"):
 
126
                v = self.original.__class__
 
127
            else:
 
128
                v = type(self.original)
 
129
            return "__class__", v
 
130
        else:
 
131
            index -= 1
 
132
            L = self.original.__dict__.items()
 
133
            L.sort()
 
134
            return L[index]
 
135
 
 
136
import types
 
137
 
 
138
for x in dict, types.DictProxyType:
 
139
    registerAdapter(DictionaryNode, x, INode)
 
140
for x in list, tuple:
 
141
    registerAdapter(ListNode, x, INode)
 
142
for x in int, str:
 
143
    registerAdapter(ConstantNode, x, INode)
 
144
 
 
145
 
 
146
class InspectorTreeModel(gtk.GenericTreeModel):
 
147
    def __init__(self, root):
 
148
        gtk.GenericTreeModel.__init__(self)
 
149
        self.root = INode(root, persist=False)
 
150
        self.root.postInit(0, None, 'root')
 
151
 
 
152
    def on_get_flags(self):
 
153
        return 0
 
154
 
 
155
    def on_get_n_columns(self):
 
156
        return 1
 
157
 
 
158
    def on_get_column_type(self, index):
 
159
        return gobject.TYPE_STRING
 
160
 
 
161
    def on_get_path(self, node):
 
162
        return node.getPath()
 
163
 
 
164
    def on_get_iter(self, path):
 
165
        x = self.root
 
166
        for elem in path:
 
167
            x = x[elem]
 
168
        return x
 
169
 
 
170
    def on_get_value(self, node, column):
 
171
        return node.format()[column]
 
172
 
 
173
    def on_iter_next(self, node):
 
174
        try:
 
175
            return node.parent[node.offset + 1]
 
176
        except IndexError:
 
177
            return None
 
178
 
 
179
    def on_iter_children(self, node):
 
180
        return node[0]
 
181
 
 
182
    def on_iter_has_child(self, node):
 
183
        return len(node)
 
184
 
 
185
    def on_iter_n_children(self, node):
 
186
        return len(node)
 
187
 
 
188
    def on_iter_nth_child(self, node, n):
 
189
        if node is None:
 
190
            return None
 
191
        return node[n]
 
192
 
 
193
    def on_iter_parent(self, node):
 
194
        return node.parent
 
195
 
 
196
 
 
197
class Inspectro:
 
198
    selected = None
 
199
    def __init__(self, o=None):
 
200
        self.xml = x = gtk.glade.XML(sibpath(__file__, "inspectro.glade"))
 
201
        self.tree_view = x.get_widget("treeview")
 
202
        colnames = ["Name", "Value"]
 
203
        for i in range(len(colnames)):
 
204
            self.tree_view.append_column(
 
205
                gtk.TreeViewColumn(
 
206
                colnames[i], gtk.CellRendererText(), text=i))
 
207
        d = {}
 
208
        for m in reflect.prefixedMethods(self, "on_"):
 
209
            d[m.im_func.__name__] = m
 
210
        self.xml.signal_autoconnect(d)
 
211
        if o is not None:
 
212
            self.inspect(o)
 
213
        self.ns = {'inspect': self.inspect}
 
214
        iwidget = x.get_widget('input')
 
215
        self.input = ConsoleInput(iwidget)
 
216
        self.input.toplevel = self
 
217
        iwidget.connect("key_press_event", self.input._on_key_press_event)
 
218
        self.output = ConsoleOutput(x.get_widget('output'))
 
219
 
 
220
    def select(self, o):
 
221
        self.selected = o
 
222
        self.ns['it'] = o
 
223
        self.xml.get_widget("itname").set_text(repr(o))
 
224
        self.xml.get_widget("itpath").set_text("???")
 
225
 
 
226
    def inspect(self, o):
 
227
        self.model = InspectorTreeModel(o)
 
228
        self.tree_view.set_model(self.model)
 
229
        self.inspected = o
 
230
 
 
231
    def do(self, command):
 
232
        filename = '<inspector>'
 
233
        try:
 
234
            print repr(command)
 
235
            try:
 
236
                code = compile(command, filename, 'eval')
 
237
            except:
 
238
                code = compile(command, filename, 'single')
 
239
            val = eval(code, self.ns, self.ns)
 
240
            if val is not None:
 
241
                print repr(val)
 
242
            self.ns['_'] = val
 
243
        except:
 
244
            log.err()
 
245
 
 
246
    def on_inspect(self, *a):
 
247
        self.inspect(self.selected)
 
248
 
 
249
    def on_inspect_new(self, *a):
 
250
        Inspectro(self.selected)
 
251
 
 
252
    def on_row_activated(self, tv, path, column):
 
253
        self.select(self.model.on_get_iter(path).original)
 
254
 
 
255
 
 
256
class LoggingProtocol(policies.ProtocolWrapper):
 
257
    """Log network traffic."""
 
258
 
 
259
    logging = True
 
260
    logViewer = None
 
261
    
 
262
    def __init__(self, *args):
 
263
        policies.ProtocolWrapper.__init__(self, *args)
 
264
        self.inLog = []
 
265
        self.outLog = []
 
266
 
 
267
    def write(self, data):
 
268
        if self.logging:
 
269
            self.outLog.append((time.time(), data))
 
270
            if self.logViewer:
 
271
                self.logViewer.updateOut(self.outLog[-1])
 
272
        policies.ProtocolWrapper.write(self, data)
 
273
 
 
274
    def dataReceived(self, data):
 
275
        if self.logging:
 
276
            self.inLog.append((time.time(), data))
 
277
            if self.logViewer:
 
278
                self.logViewer.updateIn(self.inLog[-1])
 
279
        policies.ProtocolWrapper.dataReceived(self, data)
 
280
 
 
281
    def __repr__(self):
 
282
        r = "wrapped " + repr(self.wrappedProtocol)
 
283
        if self.logging:
 
284
            r += " (logging)"
 
285
        return r
 
286
 
 
287
 
 
288
class LoggingFactory(policies.WrappingFactory):
 
289
    """Wrap protocols with logging wrappers."""
 
290
 
 
291
    protocol = LoggingProtocol
 
292
    logging = True
 
293
    
 
294
    def buildProtocol(self, addr):
 
295
        p = self.protocol(self, self.wrappedFactory.buildProtocol(addr))    
 
296
        p.logging = self.logging
 
297
        return p
 
298
 
 
299
    def __repr__(self):
 
300
        r = "wrapped " + repr(self.wrappedFactory)
 
301
        if self.logging:
 
302
            r += " (logging)"
 
303
        return r
 
304
 
 
305
 
 
306
class LogViewer:
 
307
    """Display log of network traffic."""
 
308
    
 
309
    def __init__(self, p):
 
310
        self.p = p
 
311
        vals = [time.time()]
 
312
        if p.inLog:
 
313
            vals.append(p.inLog[0][0])
 
314
        if p.outLog:
 
315
            vals.append(p.outLog[0][0])
 
316
        self.startTime = min(vals)
 
317
        p.logViewer = self
 
318
        self.xml = x = gtk.glade.XML(sibpath(__file__, "logview.glade"))
 
319
        self.xml.signal_autoconnect(self)
 
320
        self.loglist = self.xml.get_widget("loglist")
 
321
        # setup model, connect it to my treeview
 
322
        self.model = gtk.ListStore(str, str, str)
 
323
        self.loglist.set_model(self.model)
 
324
        self.loglist.set_reorderable(1)
 
325
        self.loglist.set_headers_clickable(1)
 
326
        # self.servers.set_headers_draggable(1)
 
327
        # add a column
 
328
        for col in [
 
329
            gtk.TreeViewColumn('Time',
 
330
                               gtk.CellRendererText(),
 
331
                               text=0),
 
332
            gtk.TreeViewColumn('D',
 
333
                               gtk.CellRendererText(),
 
334
                               text=1),
 
335
            gtk.TreeViewColumn('Data',
 
336
                               gtk.CellRendererText(),
 
337
                               text=2)]:
 
338
            self.loglist.append_column(col)
 
339
            col.set_resizable(1)
 
340
        r = []
 
341
        for t, data in p.inLog:
 
342
            r.append(((str(t - self.startTime), "R", repr(data)[1:-1])))
 
343
        for t, data in p.outLog:
 
344
            r.append(((str(t - self.startTime), "S", repr(data)[1:-1])))
 
345
        r.sort()
 
346
        for i in r:
 
347
            self.model.append(i)
 
348
    
 
349
    def updateIn(self, (time, data)):
 
350
        self.model.append((str(time - self.startTime), "R", repr(data)[1:-1]))
 
351
 
 
352
    def updateOut(self, (time, data)):
 
353
        self.model.append((str(time - self.startTime), "S", repr(data)[1:-1]))
 
354
 
 
355
    def on_logview_destroy(self, w):
 
356
        self.p.logViewer = None
 
357
        del self.p
 
358
 
 
359
 
 
360
def main():
 
361
    x = Inspectro()
 
362
    x.inspect(x)
 
363
    gtk.main()
 
364
 
 
365
if __name__ == '__main__':
 
366
    import sys
 
367
    log.startLogging(sys.stdout)
 
368
    main()
 
369