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