update ParaVM/HVM help text
[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 from StringIO import StringIO
16
17 def 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
26 def printError():
27     """Revert stderr to stdout, and print the contents of stderr"""
28     if isinstance(sys.stderr, StringIO):
29         print revertStandardError()
30
31 if __name__ == '__main__':
32     import atexit
33     atexit.register(printError)
34
35 import templates
36 from Cheetah.Template import Template
37 import validation
38 import cache_acls
39 from webcommon import State
40 import controls
41 from getafsgroups import getAfsGroupMembers
42 from invirt import database
43 from invirt.database import Machine, CDROM, session, connect, MachineAccess, Type, Autoinstall
44 from invirt.config import structs as config
45 from invirt.common import InvalidInput, CodeError
46
47 def pathSplit(path):
48     if path.startswith('/'):
49         path = path[1:]
50     i = path.find('/')
51     if i == -1:
52         i = len(path)
53     return path[:i], path[i:]
54
55 class Checkpoint:
56     def __init__(self):
57         self.start_time = time.time()
58         self.checkpoints = []
59
60     def checkpoint(self, s):
61         self.checkpoints.append((s, time.time()))
62
63     def __str__(self):
64         return ('Timing info:\n%s\n' %
65                 '\n'.join(['%s: %s' % (d, t - self.start_time) for
66                            (d, t) in self.checkpoints]))
67
68 checkpoint = Checkpoint()
69
70 def jquote(string):
71     return "'" + string.replace('\\', '\\\\').replace("'", "\\'").replace('\n', '\\n') + "'"
72
73 def helppopup(subj):
74     """Return HTML code for a (?) link to a specified help topic"""
75     return ('<span class="helplink"><a href="help?' +
76             cgi.escape(urllib.urlencode(dict(subject=subj, simple='true')))
77             +'" target="_blank" ' +
78             'onclick="return helppopup(' + cgi.escape(jquote(subj)) + ')">(?)</a></span>')
79
80 def makeErrorPre(old, addition):
81     if addition is None:
82         return
83     if old:
84         return old[:-6]  + '\n----\n' + str(addition) + '</pre>'
85     else:
86         return '<p>STDERR:</p><pre>' + str(addition) + '</pre>'
87
88 Template.database = database
89 Template.config = config
90 Template.helppopup = staticmethod(helppopup)
91 Template.err = None
92
93 class JsonDict:
94     """Class to store a dictionary that will be converted to JSON"""
95     def __init__(self, **kws):
96         self.data = kws
97         if 'err' in kws:
98             err = kws['err']
99             del kws['err']
100             self.addError(err)
101
102     def __str__(self):
103         return simplejson.dumps(self.data)
104
105     def addError(self, text):
106         """Add stderr text to be displayed on the website."""
107         self.data['err'] = \
108             makeErrorPre(self.data.get('err'), text)
109
110 class Defaults:
111     """Class to store default values for fields."""
112     memory = 256
113     disk = 4.0
114     cdrom = ''
115     autoinstall = ''
116     name = ''
117     description = ''
118     type = 'linux-hvm'
119
120     def __init__(self, max_memory=None, max_disk=None, **kws):
121         if max_memory is not None:
122             self.memory = min(self.memory, max_memory)
123         if max_disk is not None:
124             self.max_disk = min(self.disk, max_disk)
125         for key in kws:
126             setattr(self, key, kws[key])
127
128
129
130 DEFAULT_HEADERS = {'Content-Type': 'text/html'}
131
132 def invalidInput(op, username, fields, err, emsg):
133     """Print an error page when an InvalidInput exception occurs"""
134     d = dict(op=op, user=username, err_field=err.err_field,
135              err_value=str(err.err_value), stderr=emsg,
136              errorMessage=str(err))
137     return templates.invalid(searchList=[d])
138
139 def hasVnc(status):
140     """Does the machine with a given status list support VNC?"""
141     if status is None:
142         return False
143     for l in status:
144         if l[0] == 'device' and l[1][0] == 'vfb':
145             d = dict(l[1][1:])
146             return 'location' in d
147     return False
148
149 def parseCreate(username, state, fields):
150     kws = dict([(kw, fields.getfirst(kw)) for kw in 'name description owner memory disksize vmtype cdrom autoinstall'.split()])
151     validate = validation.Validate(username, state, strict=True, **kws)
152     return dict(contact=username, name=validate.name, description=validate.description, memory=validate.memory,
153                 disksize=validate.disksize, owner=validate.owner, machine_type=validate.vmtype,
154                 cdrom=getattr(validate, 'cdrom', None),
155                 autoinstall=getattr(validate, 'autoinstall', None))
156
157 def create(username, state, path, fields):
158     """Handler for create requests."""
159     try:
160         parsed_fields = parseCreate(username, state, fields)
161         machine = controls.createVm(username, state, **parsed_fields)
162     except InvalidInput, err:
163         pass
164     else:
165         err = None
166     state.clear() #Changed global state
167     d = getListDict(username, state)
168     d['err'] = err
169     if err:
170         for field in fields.keys():
171             setattr(d['defaults'], field, fields.getfirst(field))
172     else:
173         d['new_machine'] = parsed_fields['name']
174     return templates.list(searchList=[d])
175
176
177 def getListDict(username, state):
178     """Gets the list of local variables used by list.tmpl."""
179     checkpoint.checkpoint('Starting')
180     machines = state.machines
181     checkpoint.checkpoint('Got my machines')
182     on = {}
183     has_vnc = {}
184     xmlist = state.xmlist
185     checkpoint.checkpoint('Got uptimes')
186     can_clone = 'ice3' not in state.xmlist_raw
187     for m in machines:
188         if m not in xmlist:
189             has_vnc[m] = 'Off'
190             m.uptime = None
191         else:
192             m.uptime = xmlist[m]['uptime']
193             if xmlist[m]['console']:
194                 has_vnc[m] = True
195             elif m.type.hvm:
196                 has_vnc[m] = "WTF?"
197             else:
198                 has_vnc[m] = "ParaVM"+helppopup("ParaVM Console")
199     max_memory = validation.maxMemory(username, state)
200     max_disk = validation.maxDisk(username)
201     checkpoint.checkpoint('Got max mem/disk')
202     defaults = Defaults(max_memory=max_memory,
203                         max_disk=max_disk,
204                         owner=username,
205                         cdrom='gutsy-i386')
206     checkpoint.checkpoint('Got defaults')
207     def sortkey(machine):
208         return (machine.owner != username, machine.owner, machine.name)
209     machines = sorted(machines, key=sortkey)
210     d = dict(user=username,
211              cant_add_vm=validation.cantAddVm(username, state),
212              max_memory=max_memory,
213              max_disk=max_disk,
214              defaults=defaults,
215              machines=machines,
216              has_vnc=has_vnc,
217              can_clone=can_clone)
218     return d
219
220 def listVms(username, state, path, fields):
221     """Handler for list requests."""
222     checkpoint.checkpoint('Getting list dict')
223     d = getListDict(username, state)
224     checkpoint.checkpoint('Got list dict')
225     return templates.list(searchList=[d])
226
227 def vnc(username, state, path, fields):
228     """VNC applet page.
229
230     Note that due to same-domain restrictions, the applet connects to
231     the webserver, which needs to forward those requests to the xen
232     server.  The Xen server runs another proxy that (1) authenticates
233     and (2) finds the correct port for the VM.
234
235     You might want iptables like:
236
237     -t nat -A PREROUTING -s ! 18.181.0.60 -i eth1 -p tcp -m tcp \
238       --dport 10003 -j DNAT --to-destination 18.181.0.60:10003
239     -t nat -A POSTROUTING -d 18.181.0.60 -o eth1 -p tcp -m tcp \
240       --dport 10003 -j SNAT --to-source 18.187.7.142
241     -A FORWARD -d 18.181.0.60 -i eth1 -o eth1 -p tcp -m tcp \
242       --dport 10003 -j ACCEPT
243
244     Remember to enable iptables!
245     echo 1 > /proc/sys/net/ipv4/ip_forward
246     """
247     machine = validation.Validate(username, state, machine_id=fields.getfirst('machine_id')).machine
248
249     token = controls.vnctoken(machine)
250     host = controls.listHost(machine)
251     if host:
252         port = 10003 + [h.hostname for h in config.hosts].index(host)
253     else:
254         port = 5900 # dummy
255
256     status = controls.statusInfo(machine)
257     has_vnc = hasVnc(status)
258
259     d = dict(user=username,
260              on=status,
261              has_vnc=has_vnc,
262              machine=machine,
263              hostname=state.environ.get('SERVER_NAME', 'localhost'),
264              port=port,
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 + '.' + config.dns.domains[0]
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, path, 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     session.begin()
355     try:
356         kws = dict([(kw, fields.getfirst(kw)) for kw in 'machine_id owner admin contact name description 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                 session.save_or_update(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, 'description'):
382             machine.description = validate.description
383         if hasattr(validate, 'admin') and validate.admin != machine.administrator:
384             machine.administrator = validate.admin
385             update_acl = True
386         if hasattr(validate, 'contact'):
387             machine.contact = validate.contact
388
389         session.save_or_update(machine)
390         if update_acl:
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
404 def 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
424 def helpHandler(username, state, path, fields):
425     """Handler for help messages."""
426     simple = fields.getfirst('simple')
427     subjects = fields.getlist('subject')
428
429     help_mapping = {
430                     'Autoinstalls': """
431 The autoinstaller builds a minimal Debian or Ubuntu system to run as a
432 ParaVM.  You can access the resulting system by logging into the <a
433 href="help?simple=true&subject=ParaVM+Console">serial console server</a>
434 with your Kerberos tickets; there is no root password so sshd will
435 refuse login.</p>
436
437 <p>Under the covers, the autoinstaller uses our own patched version of
438 xen-create-image, which is a tool based on debootstrap.  If you log
439 into the serial console while the install is running, you can watch
440 it.
441 """,
442                     'ParaVM Console': """
443 ParaVM machines do not support local console access over VNC.  To
444 access the serial console of these machines, you can SSH with Kerberos
445 to %s, using the name of the machine as your
446 username.""" % config.console.hostname,
447                     'HVM/ParaVM': """
448 HVM machines use the virtualization features of the processor, while
449 ParaVM machines rely on a modified kernel to communicate directly with
450 the hypervisor.  HVMs support boot CDs of any operating system, and
451 the VNC console applet.  The three-minute autoinstaller produces
452 ParaVMs.  ParaVMs typically are more efficient, and always support the
453 console server.</p>
454
455 <p>We recommend using a ParaVM when possible and an HVM when necessary.
456 """,
457                     'CPU Weight': """
458 Don't ask us!  We're as mystified as you are.""",
459                     'Owner': """
460 The owner field is used to determine <a
461 href="help?subject=Quotas">quotas</a>.  It must be the name of a
462 locker that you are an AFS administrator of.  In particular, you or an
463 AFS group you are a member of must have AFS rlidwka bits on the
464 locker.  You can check who administers the LOCKER locker using the
465 commands 'attach LOCKER; fs la /mit/LOCKER' on Athena.)  See also <a
466 href="help?subject=Administrator">administrator</a>.""",
467                     'Administrator': """
468 The administrator field determines who can access the console and
469 power on and off the machine.  This can be either a user or a moira
470 group.""",
471                     'Quotas': """
472 Quotas are determined on a per-locker basis.  Each locker may have a
473 maximum of 512 megabytes of active ram, 50 gigabytes of disk, and 4
474 active machines.""",
475                     'Console': """
476 <strong>Framebuffer:</strong> At a Linux boot prompt in your VM, try
477 setting <tt>fb=false</tt> to disable the framebuffer.  If you don't,
478 your machine will run just fine, but the applet's display of the
479 console will suffer artifacts.
480 """,
481                     'Windows': """
482 <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>
483 <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.
484 """
485                     }
486
487     if not subjects:
488         subjects = sorted(help_mapping.keys())
489
490     d = dict(user=username,
491              simple=simple,
492              subjects=subjects,
493              mapping=help_mapping)
494
495     return templates.help(searchList=[d])
496
497
498 def badOperation(u, s, p, e):
499     """Function called when accessing an unknown URI."""
500     return ({'Status': '404 Not Found'}, 'Invalid operation.')
501
502 def infoDict(username, state, machine):
503     """Get the variables used by info.tmpl."""
504     status = controls.statusInfo(machine)
505     checkpoint.checkpoint('Getting status info')
506     has_vnc = hasVnc(status)
507     if status is None:
508         main_status = dict(name=machine.name,
509                            memory=str(machine.memory))
510         uptime = None
511         cputime = None
512     else:
513         main_status = dict(status[1:])
514         main_status['host'] = controls.listHost(machine)
515         start_time = float(main_status.get('start_time', 0))
516         uptime = datetime.timedelta(seconds=int(time.time()-start_time))
517         cpu_time_float = float(main_status.get('cpu_time', 0))
518         cputime = datetime.timedelta(seconds=int(cpu_time_float))
519     checkpoint.checkpoint('Status')
520     display_fields = """name uptime memory state cpu_weight on_reboot 
521      on_poweroff on_crash on_xend_start on_xend_stop bootloader""".split()
522     display_fields = [('name', 'Name'),
523                       ('description', 'Description'),
524                       ('owner', 'Owner'),
525                       ('administrator', 'Administrator'),
526                       ('contact', 'Contact'),
527                       ('type', 'Type'),
528                       'NIC_INFO',
529                       ('uptime', 'uptime'),
530                       ('cputime', 'CPU usage'),
531                       ('host', 'Hosted on'),
532                       ('memory', 'RAM'),
533                       'DISK_INFO',
534                       ('state', 'state (xen format)'),
535                       ('cpu_weight', 'CPU weight'+helppopup('CPU Weight')),
536                       ('on_reboot', 'Action on VM reboot'),
537                       ('on_poweroff', 'Action on VM poweroff'),
538                       ('on_crash', 'Action on VM crash'),
539                       ('on_xend_start', 'Action on Xen start'),
540                       ('on_xend_stop', 'Action on Xen stop'),
541                       ('bootloader', 'Bootloader options'),
542                       ]
543     fields = []
544     machine_info = {}
545     machine_info['name'] = machine.name
546     machine_info['description'] = machine.description
547     machine_info['type'] = machine.type.hvm and 'HVM' or 'ParaVM'
548     machine_info['owner'] = machine.owner
549     machine_info['administrator'] = machine.administrator
550     machine_info['contact'] = machine.contact
551
552     nic_fields = getNicInfo(machine_info, machine)
553     nic_point = display_fields.index('NIC_INFO')
554     display_fields = (display_fields[:nic_point] + nic_fields +
555                       display_fields[nic_point+1:])
556
557     disk_fields = getDiskInfo(machine_info, machine)
558     disk_point = display_fields.index('DISK_INFO')
559     display_fields = (display_fields[:disk_point] + disk_fields +
560                       display_fields[disk_point+1:])
561
562     main_status['memory'] += ' MiB'
563     for field, disp in display_fields:
564         if field in ('uptime', 'cputime') and locals()[field] is not None:
565             fields.append((disp, locals()[field]))
566         elif field in machine_info:
567             fields.append((disp, machine_info[field]))
568         elif field in main_status:
569             fields.append((disp, main_status[field]))
570         else:
571             pass
572             #fields.append((disp, None))
573
574     checkpoint.checkpoint('Got fields')
575
576
577     max_mem = validation.maxMemory(machine.owner, state, machine, False)
578     checkpoint.checkpoint('Got mem')
579     max_disk = validation.maxDisk(machine.owner, machine)
580     defaults = Defaults()
581     for name in 'machine_id name description administrator owner memory contact'.split():
582         setattr(defaults, name, getattr(machine, name))
583     defaults.type = machine.type.type_id
584     defaults.disk = "%0.2f" % (machine.disks[0].size/1024.)
585     checkpoint.checkpoint('Got defaults')
586     d = dict(user=username,
587              on=status is not None,
588              machine=machine,
589              defaults=defaults,
590              has_vnc=has_vnc,
591              uptime=str(uptime),
592              ram=machine.memory,
593              max_mem=max_mem,
594              max_disk=max_disk,
595              owner_help=helppopup("Owner"),
596              fields = fields)
597     return d
598
599 def info(username, state, path, fields):
600     """Handler for info on a single VM."""
601     machine = validation.Validate(username, state, machine_id=fields.getfirst('machine_id')).machine
602     d = infoDict(username, state, machine)
603     checkpoint.checkpoint('Got infodict')
604     return templates.info(searchList=[d])
605
606 def unauthFront(_, _2, _3, fields):
607     """Information for unauth'd users."""
608     return templates.unauth(searchList=[{'simple' : True}])
609
610 def admin(username, state, path, fields):
611     if path == '':
612         return ({'Status': '303 See Other',
613                  'Location': 'admin/'},
614                 "You shouldn't see this message.")
615     if not username in getAfsGroupMembers(config.web.adminacl, 'athena.mit.edu'):
616         raise InvalidInput('username', username,
617                            'Not in admin group %s.' % config.web.adminacl)
618     newstate = State(username, isadmin=True)
619     newstate.environ = state.environ
620     return handler(username, newstate, path, fields)
621
622 def throwError(_, __, ___, ____):
623     """Throw an error, to test the error-tracing mechanisms."""
624     raise RuntimeError("test of the emergency broadcast system")
625
626 mapping = dict(list=listVms,
627                vnc=vnc,
628                command=command,
629                modify=modify,
630                info=info,
631                create=create,
632                help=helpHandler,
633                unauth=unauthFront,
634                admin=admin,
635                overlord=admin,
636                errortest=throwError)
637
638 def printHeaders(headers):
639     """Print a dictionary as HTTP headers."""
640     for key, value in headers.iteritems():
641         print '%s: %s' % (key, value)
642     print
643
644 def send_error_mail(subject, body):
645     import subprocess
646
647     to = config.web.errormail
648     mail = """To: %s
649 From: root@%s
650 Subject: %s
651
652 %s
653 """ % (to, config.web.hostname, subject, body)
654     p = subprocess.Popen(['/usr/sbin/sendmail', '-f', to, to],
655                          stdin=subprocess.PIPE)
656     p.stdin.write(mail)
657     p.stdin.close()
658     p.wait()
659
660 def show_error(op, username, fields, err, emsg, traceback):
661     """Print an error page when an exception occurs"""
662     d = dict(op=op, user=username, fields=fields,
663              errorMessage=str(err), stderr=emsg, traceback=traceback)
664     details = templates.error_raw(searchList=[d])
665     exclude = config.web.errormail_exclude
666     if username not in exclude and '*' not in exclude:
667         send_error_mail('xvm error on %s for %s: %s' % (op, username, err),
668                         details)
669     d['details'] = details
670     return templates.error(searchList=[d])
671
672 def getUser(environ):
673     """Return the current user based on the SSL environment variables"""
674     user = environ.get('REMOTE_USER')
675     if user is None:
676         return
677     
678     if environ.get('AUTH_TYPE') == 'Negotiate':
679         # Convert the krb5 principal into a krb4 username
680         if not user.endswith('@%s' % config.authn[0].realm):
681             return
682         else:
683             return user.split('@')[0].replace('/', '.')
684     else:
685         return user
686
687 def handler(username, state, path, fields):
688     operation, path = pathSplit(path)
689     if not operation:
690         operation = 'list'
691     print 'Starting', operation
692     fun = mapping.get(operation, badOperation)
693     return fun(username, state, path, fields)
694
695 class App:
696     def __init__(self, environ, start_response):
697         self.environ = environ
698         self.start = start_response
699
700         self.username = getUser(environ)
701         self.state = State(self.username)
702         self.state.environ = environ
703
704         random.seed() #sigh
705
706     def __iter__(self):
707         start_time = time.time()
708         database.clear_cache()
709         sys.stderr = StringIO()
710         fields = cgi.FieldStorage(fp=self.environ['wsgi.input'], environ=self.environ)
711         operation = self.environ.get('PATH_INFO', '')
712         if not operation:
713             self.start("301 Moved Permanently", [('Location', './')])
714             return
715         if self.username is None:
716             operation = 'unauth'
717
718         try:
719             checkpoint.checkpoint('Before')
720             output = handler(self.username, self.state, operation, fields)
721             checkpoint.checkpoint('After')
722
723             headers = dict(DEFAULT_HEADERS)
724             if isinstance(output, tuple):
725                 new_headers, output = output
726                 headers.update(new_headers)
727             e = revertStandardError()
728             if e:
729                 if hasattr(output, 'addError'):
730                     output.addError(e)
731                 else:
732                     # This only happens on redirects, so it'd be a pain to get
733                     # the message to the user.  Maybe in the response is useful.
734                     output = output + '\n\nstderr:\n' + e
735             output_string =  str(output)
736             checkpoint.checkpoint('output as a string')
737         except Exception, err:
738             if not fields.has_key('js'):
739                 if isinstance(err, InvalidInput):
740                     self.start('200 OK', [('Content-Type', 'text/html')])
741                     e = revertStandardError()
742                     yield str(invalidInput(operation, self.username, fields,
743                                            err, e))
744                     return
745             import traceback
746             self.start('500 Internal Server Error',
747                        [('Content-Type', 'text/html')])
748             e = revertStandardError()
749             s = show_error(operation, self.username, fields,
750                            err, e, traceback.format_exc())
751             yield str(s)
752             return
753         status = headers.setdefault('Status', '200 OK')
754         del headers['Status']
755         self.start(status, headers.items())
756         yield output_string
757         if fields.has_key('timedebug'):
758             yield '<pre>%s</pre>' % cgi.escape(str(checkpoint))
759
760 def constructor():
761     connect()
762     return App
763
764 def main():
765     from flup.server.fcgi_fork import WSGIServer
766     WSGIServer(constructor()).run()
767
768 if __name__ == '__main__':
769     main()