send mail on non-CodeError exceptions
[invirt/packages/invirt-web.git] / code / main.py
1 #!/usr/bin/python
2 """Main CGI script for web interface"""
3
4 import base64
5 import cPickle
6 import cgi
7 import datetime
8 import hmac
9 import sha
10 import simplejson
11 import sys
12 import time
13 import urllib
14 from StringIO import StringIO
15
16 def revertStandardError():
17     """Move stderr to stdout, and return the contents of the old stderr."""
18     errio = sys.stderr
19     if not isinstance(errio, StringIO):
20         return None
21     sys.stderr = sys.stdout
22     errio.seek(0)
23     return errio.read()
24
25 def printError():
26     """Revert stderr to stdout, and print the contents of stderr"""
27     if isinstance(sys.stderr, StringIO):
28         print revertStandardError()
29
30 if __name__ == '__main__':
31     import atexit
32     atexit.register(printError)
33     sys.stderr = StringIO()
34
35 sys.path.append('/home/ecprice/.local/lib/python2.5/site-packages')
36
37 import templates
38 from Cheetah.Template import Template
39 import sipb_xen_database
40 from sipb_xen_database import Machine, CDROM, ctx, connect, MachineAccess, Type, Autoinstall
41 import validation
42 import cache_acls
43 from webcommon import InvalidInput, CodeError, State
44 import controls
45
46 class Checkpoint:
47     def __init__(self):
48         self.start_time = time.time()
49         self.checkpoints = []
50
51     def checkpoint(self, s):
52         self.checkpoints.append((s, time.time()))
53
54     def __str__(self):
55         return ('Timing info:\n%s\n' %
56                 '\n'.join(['%s: %s' % (d, t - self.start_time) for
57                            (d, t) in self.checkpoints]))
58
59 checkpoint = Checkpoint()
60
61 def jquote(string):
62     return "'" + string.replace('\\', '\\\\').replace("'", "\\'").replace('\n', '\\n') + "'"
63
64 def helppopup(subj):
65     """Return HTML code for a (?) link to a specified help topic"""
66     return ('<span class="helplink"><a href="help?' +
67             cgi.escape(urllib.urlencode(dict(subject=subj, simple='true')))
68             +'" target="_blank" ' +
69             'onclick="return helppopup(' + cgi.escape(jquote(subj)) + ')">(?)</a></span>')
70
71 def makeErrorPre(old, addition):
72     if addition is None:
73         return
74     if old:
75         return old[:-6]  + '\n----\n' + str(addition) + '</pre>'
76     else:
77         return '<p>STDERR:</p><pre>' + str(addition) + '</pre>'
78
79 Template.sipb_xen_database = sipb_xen_database
80 Template.helppopup = staticmethod(helppopup)
81 Template.err = None
82
83 class JsonDict:
84     """Class to store a dictionary that will be converted to JSON"""
85     def __init__(self, **kws):
86         self.data = kws
87         if 'err' in kws:
88             err = kws['err']
89             del kws['err']
90             self.addError(err)
91
92     def __str__(self):
93         return simplejson.dumps(self.data)
94
95     def addError(self, text):
96         """Add stderr text to be displayed on the website."""
97         self.data['err'] = \
98             makeErrorPre(self.data.get('err'), text)
99
100 class Defaults:
101     """Class to store default values for fields."""
102     memory = 256
103     disk = 4.0
104     cdrom = ''
105     autoinstall = ''
106     name = ''
107     type = 'linux-hvm'
108
109     def __init__(self, max_memory=None, max_disk=None, **kws):
110         if max_memory is not None:
111             self.memory = min(self.memory, max_memory)
112         if max_disk is not None:
113             self.max_disk = min(self.disk, max_disk)
114         for key in kws:
115             setattr(self, key, kws[key])
116
117
118
119 DEFAULT_HEADERS = {'Content-Type': 'text/html'}
120
121 def error(op, username, fields, err, emsg):
122     """Print an error page when a CodeError occurs"""
123     d = dict(op=op, user=username, errorMessage=str(err),
124              stderr=emsg)
125     return templates.error(searchList=[d])
126
127 def invalidInput(op, username, fields, err, emsg):
128     """Print an error page when an InvalidInput exception occurs"""
129     d = dict(op=op, user=username, err_field=err.err_field,
130              err_value=str(err.err_value), stderr=emsg,
131              errorMessage=str(err))
132     return templates.invalid(searchList=[d])
133
134 def hasVnc(status):
135     """Does the machine with a given status list support VNC?"""
136     if status is None:
137         return False
138     for l in status:
139         if l[0] == 'device' and l[1][0] == 'vfb':
140             d = dict(l[1][1:])
141             return 'location' in d
142     return False
143
144 def parseCreate(username, state, fields):
145     kws = dict([(kw, fields.getfirst(kw)) for kw in 'name owner memory disksize vmtype cdrom clone_from'.split()])
146     validate = validation.Validate(username, state, strict=True, **kws)
147     return dict(contact=username, name=validate.name, memory=validate.memory,
148                 disksize=validate.disksize, owner=validate.owner, machine_type=validate.vmtype,
149                 cdrom=getattr(validate, 'cdrom', None),
150                 clone_from=getattr(validate, 'clone_from', None))
151
152 def create(username, state, fields):
153     """Handler for create requests."""
154     try:
155         parsed_fields = parseCreate(username, state, fields)
156         machine = controls.createVm(username, state, **parsed_fields)
157     except InvalidInput, err:
158         pass
159     else:
160         err = None
161     state.clear() #Changed global state
162     d = getListDict(username, state)
163     d['err'] = err
164     if err:
165         for field in fields.keys():
166             setattr(d['defaults'], field, fields.getfirst(field))
167     else:
168         d['new_machine'] = parsed_fields['name']
169     return templates.list(searchList=[d])
170
171
172 def getListDict(username, state):
173     """Gets the list of local variables used by list.tmpl."""
174     checkpoint.checkpoint('Starting')
175     machines = state.machines
176     checkpoint.checkpoint('Got my machines')
177     on = {}
178     has_vnc = {}
179     xmlist = state.xmlist
180     checkpoint.checkpoint('Got uptimes')
181     can_clone = 'ice3' not in state.xmlist_raw
182     for m in machines:
183         if m not in xmlist:
184             has_vnc[m] = 'Off'
185             m.uptime = None
186         else:
187             m.uptime = xmlist[m]['uptime']
188             if xmlist[m]['console']:
189                 has_vnc[m] = True
190             elif m.type.hvm:
191                 has_vnc[m] = "WTF?"
192             else:
193                 has_vnc[m] = "ParaVM"+helppopup("ParaVM Console")
194     max_memory = validation.maxMemory(username, state)
195     max_disk = validation.maxDisk(username)
196     checkpoint.checkpoint('Got max mem/disk')
197     defaults = Defaults(max_memory=max_memory,
198                         max_disk=max_disk,
199                         owner=username,
200                         cdrom='gutsy-i386')
201     checkpoint.checkpoint('Got defaults')
202     def sortkey(machine):
203         return (machine.owner != username, machine.owner, machine.name)
204     machines = sorted(machines, key=sortkey)
205     d = dict(user=username,
206              cant_add_vm=validation.cantAddVm(username, state),
207              max_memory=max_memory,
208              max_disk=max_disk,
209              defaults=defaults,
210              machines=machines,
211              has_vnc=has_vnc,
212              can_clone=can_clone)
213     return d
214
215 def listVms(username, state, fields):
216     """Handler for list requests."""
217     checkpoint.checkpoint('Getting list dict')
218     d = getListDict(username, state)
219     checkpoint.checkpoint('Got list dict')
220     return templates.list(searchList=[d])
221
222 def vnc(username, state, fields):
223     """VNC applet page.
224
225     Note that due to same-domain restrictions, the applet connects to
226     the webserver, which needs to forward those requests to the xen
227     server.  The Xen server runs another proxy that (1) authenticates
228     and (2) finds the correct port for the VM.
229
230     You might want iptables like:
231
232     -t nat -A PREROUTING -s ! 18.181.0.60 -i eth1 -p tcp -m tcp \
233       --dport 10003 -j DNAT --to-destination 18.181.0.60:10003
234     -t nat -A POSTROUTING -d 18.181.0.60 -o eth1 -p tcp -m tcp \
235       --dport 10003 -j SNAT --to-source 18.187.7.142
236     -A FORWARD -d 18.181.0.60 -i eth1 -o eth1 -p tcp -m tcp \
237       --dport 10003 -j ACCEPT
238
239     Remember to enable iptables!
240     echo 1 > /proc/sys/net/ipv4/ip_forward
241     """
242     machine = validation.Validate(username, state, machine_id=fields.getfirst('machine_id')).machine
243
244     TOKEN_KEY = "0M6W0U1IXexThi5idy8mnkqPKEq1LtEnlK/pZSn0cDrN"
245
246     data = {}
247     data["user"] = username
248     data["machine"] = machine.name
249     data["expires"] = time.time()+(5*60)
250     pickled_data = cPickle.dumps(data)
251     m = hmac.new(TOKEN_KEY, digestmod=sha)
252     m.update(pickled_data)
253     token = {'data': pickled_data, 'digest': m.digest()}
254     token = cPickle.dumps(token)
255     token = base64.urlsafe_b64encode(token)
256
257     status = controls.statusInfo(machine)
258     has_vnc = hasVnc(status)
259
260     d = dict(user=username,
261              on=status,
262              has_vnc=has_vnc,
263              machine=machine,
264              hostname=state.environ.get('SERVER_NAME', 'localhost'),
265              authtoken=token)
266     return templates.vnc(searchList=[d])
267
268 def getHostname(nic):
269     """Find the hostname associated with a NIC.
270
271     XXX this should be merged with the similar logic in DNS and DHCP.
272     """
273     if nic.hostname and '.' in nic.hostname:
274         return nic.hostname
275     elif nic.machine:
276         return nic.machine.name + '.xvm.mit.edu'
277     else:
278         return None
279
280
281 def getNicInfo(data_dict, machine):
282     """Helper function for info, get data on nics for a machine.
283
284     Modifies data_dict to include the relevant data, and returns a list
285     of (key, name) pairs to display "name: data_dict[key]" to the user.
286     """
287     data_dict['num_nics'] = len(machine.nics)
288     nic_fields_template = [('nic%s_hostname', 'NIC %s Hostname'),
289                            ('nic%s_mac', 'NIC %s MAC Addr'),
290                            ('nic%s_ip', 'NIC %s IP'),
291                            ]
292     nic_fields = []
293     for i in range(len(machine.nics)):
294         nic_fields.extend([(x % i, y % i) for x, y in nic_fields_template])
295         if not i:
296             data_dict['nic%s_hostname' % i] = getHostname(machine.nics[i])
297         data_dict['nic%s_mac' % i] = machine.nics[i].mac_addr
298         data_dict['nic%s_ip' % i] = machine.nics[i].ip
299     if len(machine.nics) == 1:
300         nic_fields = [(x, y.replace('NIC 0 ', '')) for x, y in nic_fields]
301     return nic_fields
302
303 def getDiskInfo(data_dict, machine):
304     """Helper function for info, get data on disks for a machine.
305
306     Modifies data_dict to include the relevant data, and returns a list
307     of (key, name) pairs to display "name: data_dict[key]" to the user.
308     """
309     data_dict['num_disks'] = len(machine.disks)
310     disk_fields_template = [('%s_size', '%s size')]
311     disk_fields = []
312     for disk in machine.disks:
313         name = disk.guest_device_name
314         disk_fields.extend([(x % name, y % name) for x, y in
315                             disk_fields_template])
316         data_dict['%s_size' % name] = "%0.1f GiB" % (disk.size / 1024.)
317     return disk_fields
318
319 def command(username, state, fields):
320     """Handler for running commands like boot and delete on a VM."""
321     back = fields.getfirst('back')
322     try:
323         d = controls.commandResult(username, state, fields)
324         if d['command'] == 'Delete VM':
325             back = 'list'
326     except InvalidInput, err:
327         if not back:
328             raise
329         print >> sys.stderr, err
330         result = err
331     else:
332         result = 'Success!'
333         if not back:
334             return templates.command(searchList=[d])
335     if back == 'list':
336         state.clear() #Changed global state
337         d = getListDict(username, state)
338         d['result'] = result
339         return templates.list(searchList=[d])
340     elif back == 'info':
341         machine = validation.Validate(username, state, machine_id=fields.getfirst('machine_id')).machine
342         return ({'Status': '303 See Other',
343                  'Location': '/info?machine_id=%d' % machine.machine_id},
344                 "You shouldn't see this message.")
345     else:
346         raise InvalidInput('back', back, 'Not a known back page.')
347
348 def modifyDict(username, state, fields):
349     """Modify a machine as specified by CGI arguments.
350
351     Return a list of local variables for modify.tmpl.
352     """
353     olddisk = {}
354     transaction = ctx.current.create_transaction()
355     try:
356         kws = dict([(kw, fields.getfirst(kw)) for kw in 'machine_id owner admin contact name memory vmtype disksize'.split()])
357         validate = validation.Validate(username, state, **kws)
358         machine = validate.machine
359         oldname = machine.name
360
361         if hasattr(validate, 'memory'):
362             machine.memory = validate.memory
363
364         if hasattr(validate, 'vmtype'):
365             machine.type = validate.vmtype
366
367         if hasattr(validate, 'disksize'):
368             disksize = validate.disksize
369             disk = machine.disks[0]
370             if disk.size != disksize:
371                 olddisk[disk.guest_device_name] = disksize
372                 disk.size = disksize
373                 ctx.current.save(disk)
374
375         update_acl = False
376         if hasattr(validate, 'owner') and validate.owner != machine.owner:
377             machine.owner = validate.owner
378             update_acl = True
379         if hasattr(validate, 'name'):
380             machine.name = validate.name
381         if hasattr(validate, 'admin') and validate.admin != machine.administrator:
382             machine.administrator = validate.admin
383             update_acl = True
384         if hasattr(validate, 'contact'):
385             machine.contact = validate.contact
386
387         ctx.current.save(machine)
388         if update_acl:
389             print >> sys.stderr, machine, machine.administrator
390             cache_acls.refreshMachine(machine)
391         transaction.commit()
392     except:
393         transaction.rollback()
394         raise
395     for diskname in olddisk:
396         controls.resizeDisk(oldname, diskname, str(olddisk[diskname]))
397     if hasattr(validate, 'name'):
398         controls.renameMachine(machine, oldname, validate.name)
399     return dict(user=username,
400                 command="modify",
401                 machine=machine)
402
403 def modify(username, state, fields):
404     """Handler for modifying attributes of a machine."""
405     try:
406         modify_dict = modifyDict(username, state, fields)
407     except InvalidInput, err:
408         result = None
409         machine = validation.Validate(username, state, machine_id=fields.getfirst('machine_id')).machine
410     else:
411         machine = modify_dict['machine']
412         result = 'Success!'
413         err = None
414     info_dict = infoDict(username, state, machine)
415     info_dict['err'] = err
416     if err:
417         for field in fields.keys():
418             setattr(info_dict['defaults'], field, fields.getfirst(field))
419     info_dict['result'] = result
420     return templates.info(searchList=[info_dict])
421
422
423 def helpHandler(username, state, fields):
424     """Handler for help messages."""
425     simple = fields.getfirst('simple')
426     subjects = fields.getlist('subject')
427
428     help_mapping = {'ParaVM Console': """
429 ParaVM machines do not support local console access over VNC.  To
430 access the serial console of these machines, you can SSH with Kerberos
431 to console.xvm.mit.edu, using the name of the machine as your
432 username.""",
433                     'HVM/ParaVM': """
434 HVM machines use the virtualization features of the processor, while
435 ParaVM machines use Xen's emulation of virtualization features.  You
436 want an HVM virtualized machine.""",
437                     'CPU Weight': """
438 Don't ask us!  We're as mystified as you are.""",
439                     'Owner': """
440 The owner field is used to determine <a
441 href="help?subject=Quotas">quotas</a>.  It must be the name of a
442 locker that you are an AFS administrator of.  In particular, you or an
443 AFS group you are a member of must have AFS rlidwka bits on the
444 locker.  You can check who administers the LOCKER locker using the
445 commands 'attach LOCKER; fs la /mit/LOCKER' on Athena.)  See also <a
446 href="help?subject=Administrator">administrator</a>.""",
447                     'Administrator': """
448 The administrator field determines who can access the console and
449 power on and off the machine.  This can be either a user or a moira
450 group.""",
451                     'Quotas': """
452 Quotas are determined on a per-locker basis.  Each locker may have a
453 maximum of 512 megabytes of active ram, 50 gigabytes of disk, and 4
454 active machines.""",
455                     'Console': """
456 <strong>Framebuffer:</strong> At a Linux boot prompt in your VM, try
457 setting <tt>fb=false</tt> to disable the framebuffer.  If you don't,
458 your machine will run just fine, but the applet's display of the
459 console will suffer artifacts.
460 """
461                     }
462
463     if not subjects:
464         subjects = sorted(help_mapping.keys())
465
466     d = dict(user=username,
467              simple=simple,
468              subjects=subjects,
469              mapping=help_mapping)
470
471     return templates.help(searchList=[d])
472
473
474 def badOperation(u, s, e):
475     """Function called when accessing an unknown URI."""
476     raise CodeError("Unknown operation")
477
478 def infoDict(username, state, machine):
479     """Get the variables used by info.tmpl."""
480     status = controls.statusInfo(machine)
481     checkpoint.checkpoint('Getting status info')
482     has_vnc = hasVnc(status)
483     if status is None:
484         main_status = dict(name=machine.name,
485                            memory=str(machine.memory))
486         uptime = None
487         cputime = None
488     else:
489         main_status = dict(status[1:])
490         start_time = float(main_status.get('start_time', 0))
491         uptime = datetime.timedelta(seconds=int(time.time()-start_time))
492         cpu_time_float = float(main_status.get('cpu_time', 0))
493         cputime = datetime.timedelta(seconds=int(cpu_time_float))
494     checkpoint.checkpoint('Status')
495     display_fields = """name uptime memory state cpu_weight on_reboot 
496      on_poweroff on_crash on_xend_start on_xend_stop bootloader""".split()
497     display_fields = [('name', 'Name'),
498                       ('owner', 'Owner'),
499                       ('administrator', 'Administrator'),
500                       ('contact', 'Contact'),
501                       ('type', 'Type'),
502                       'NIC_INFO',
503                       ('uptime', 'uptime'),
504                       ('cputime', 'CPU usage'),
505                       ('memory', 'RAM'),
506                       'DISK_INFO',
507                       ('state', 'state (xen format)'),
508                       ('cpu_weight', 'CPU weight'+helppopup('CPU Weight')),
509                       ('on_reboot', 'Action on VM reboot'),
510                       ('on_poweroff', 'Action on VM poweroff'),
511                       ('on_crash', 'Action on VM crash'),
512                       ('on_xend_start', 'Action on Xen start'),
513                       ('on_xend_stop', 'Action on Xen stop'),
514                       ('bootloader', 'Bootloader options'),
515                       ]
516     fields = []
517     machine_info = {}
518     machine_info['name'] = machine.name
519     machine_info['type'] = machine.type.hvm and 'HVM' or 'ParaVM'
520     machine_info['owner'] = machine.owner
521     machine_info['administrator'] = machine.administrator
522     machine_info['contact'] = machine.contact
523
524     nic_fields = getNicInfo(machine_info, machine)
525     nic_point = display_fields.index('NIC_INFO')
526     display_fields = (display_fields[:nic_point] + nic_fields +
527                       display_fields[nic_point+1:])
528
529     disk_fields = getDiskInfo(machine_info, machine)
530     disk_point = display_fields.index('DISK_INFO')
531     display_fields = (display_fields[:disk_point] + disk_fields +
532                       display_fields[disk_point+1:])
533
534     main_status['memory'] += ' MiB'
535     for field, disp in display_fields:
536         if field in ('uptime', 'cputime') and locals()[field] is not None:
537             fields.append((disp, locals()[field]))
538         elif field in machine_info:
539             fields.append((disp, machine_info[field]))
540         elif field in main_status:
541             fields.append((disp, main_status[field]))
542         else:
543             pass
544             #fields.append((disp, None))
545
546     checkpoint.checkpoint('Got fields')
547
548
549     max_mem = validation.maxMemory(machine.owner, state, machine, False)
550     checkpoint.checkpoint('Got mem')
551     max_disk = validation.maxDisk(machine.owner, machine)
552     defaults = Defaults()
553     for name in 'machine_id name administrator owner memory contact'.split():
554         setattr(defaults, name, getattr(machine, name))
555     defaults.type = machine.type.type_id
556     defaults.disk = "%0.2f" % (machine.disks[0].size/1024.)
557     checkpoint.checkpoint('Got defaults')
558     d = dict(user=username,
559              on=status is not None,
560              machine=machine,
561              defaults=defaults,
562              has_vnc=has_vnc,
563              uptime=str(uptime),
564              ram=machine.memory,
565              max_mem=max_mem,
566              max_disk=max_disk,
567              owner_help=helppopup("Owner"),
568              fields = fields)
569     return d
570
571 def info(username, state, fields):
572     """Handler for info on a single VM."""
573     machine = validation.Validate(username, state, machine_id=fields.getfirst('machine_id')).machine
574     d = infoDict(username, state, machine)
575     checkpoint.checkpoint('Got infodict')
576     return templates.info(searchList=[d])
577
578 def unauthFront(_, _2, fields):
579     """Information for unauth'd users."""
580     return templates.unauth(searchList=[{'simple' : True}])
581
582 def throwError(_, __, ___):
583     """Throw an error, to test the error-tracing mechanisms."""
584     raise RuntimeError("This is a test of the emergency broadcast system.")
585
586 mapping = dict(list=listVms,
587                vnc=vnc,
588                command=command,
589                modify=modify,
590                info=info,
591                create=create,
592                help=helpHandler,
593                unauth=unauthFront,
594                errortest=throwError)
595
596 def printHeaders(headers):
597     """Print a dictionary as HTTP headers."""
598     for key, value in headers.iteritems():
599         print '%s: %s' % (key, value)
600     print
601
602 def send_error_mail(subject, body):
603     import subprocess
604
605     to = 'xvm@mit.edu'
606     mail = """To: %s
607 From: root@xvm.mit.edu
608 Subject: %s
609
610 %s
611 """ % (to, subject, body)
612     p = subprocess.Popen(['/usr/sbin/sendmail', to], stdin=subprocess.PIPE)
613     p.stdin.write(mail)
614     p.stdin.close()
615     p.wait()
616
617 def getUser(environ):
618     """Return the current user based on the SSL environment variables"""
619     email = environ.get('SSL_CLIENT_S_DN_Email', None)
620     if email is None:
621         return None
622     if not email.endswith('@MIT.EDU'):
623         return None
624     return email[:-8]
625
626 class App:
627     def __init__(self, environ, start_response):
628         self.environ = environ
629         self.start = start_response
630
631         self.username = getUser(environ)
632         self.state = State(self.username)
633         self.state.environ = environ
634
635     def __iter__(self):
636         fields = cgi.FieldStorage(fp=self.environ['wsgi.input'], environ=self.environ)
637         print >> sys.stderr, fields
638         operation = self.environ.get('PATH_INFO', '')
639         if not operation:
640             self.start("301 Moved Permanently", [('Location',
641                                                   self.environ['SCRIPT_NAME']+'/')])
642             return
643         if self.username is None:
644             operation = 'unauth'
645         if operation.startswith('/'):
646             operation = operation[1:]
647         if not operation:
648             operation = 'list'
649         print 'Starting', operation
650
651         start_time = time.time()
652         fun = mapping.get(operation, badOperation)
653         try:
654             checkpoint.checkpoint('Before')
655             output = fun(self.username, self.state, fields)
656             checkpoint.checkpoint('After')
657
658             headers = dict(DEFAULT_HEADERS)
659             if isinstance(output, tuple):
660                 new_headers, output = output
661                 headers.update(new_headers)
662             print 'MOO2'
663             e = revertStandardError()
664             if e:
665                 if isinstance(output, basestring):
666                     sys.stderr = StringIO()
667                     x = str(output)
668                     print >> sys.stderr, x
669                     print >> sys.stderr, 'XXX'
670                     print >> sys.stderr, e
671                     raise Exception()
672                 output.addError(e)
673             output_string =  str(output)
674             checkpoint.checkpoint('output as a string')
675         except Exception, err:
676             if not fields.has_key('js'):
677                 if isinstance(err, CodeError):
678                     self.start('500 Internal Server Error', [('Content-Type', 'text/html')])
679                     e = revertStandardError()
680                     s = error(operation, self.username, fields, err, e)
681                     yield str(s)
682                     return
683                 if isinstance(err, InvalidInput):
684                     self.start('200 OK', [('Content-Type', 'text/html')])
685                     e = revertStandardError()
686                     yield str(invalidInput(operation, self.username, fields, err, e))
687                     return
688             self.start('500 Internal Server Error', [('Content-Type', 'text/plain')])
689             import traceback
690             send_error_mail('xvm error: %s' % (err,),
691                             '%s\n' % (traceback.format_exc(),))
692             yield '''Uh-oh!  We experienced an error.
693 Sorry about that.  We've gotten mail about it.
694
695 Feel free to poke us at xvm@mit.edu if this bug is
696 consistently biting you and we don't seem to be fixing it.
697
698 In case you're curious, the gory details are here.
699 ----
700 %s
701 ----
702 %s
703 ----''' % (str(err), traceback.format_exc())
704         status = headers.setdefault('Status', '200 OK')
705         del headers['Status']
706         self.start(status, headers.items())
707         yield output_string
708         if fields.has_key('timedebug'):
709             yield '<pre>%s</pre>' % cgi.escape(str(checkpoint))
710
711 def constructor():
712     connect('postgres://sipb-xen@sipb-xen-dev.mit.edu/sipb_xen')
713     return App
714
715 def main():
716     from flup.server.fcgi_fork import WSGIServer
717     WSGIServer(constructor()).run()
718
719 if __name__ == '__main__':
720     main()