source: trunk/packages/invirt-web/code/main.py @ 1542

Last change on this file since 1542 was 1469, checked in by broder, 15 years ago

When getting the authtoken in the web interface, call remctl from the
right place

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