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