Stub InvirtWeb implementation
[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 from view import View
19
20 class InvirtWeb(View):
21     @cherrypy.expose
22     def helloworld(self):
23         return "Hello world!"
24
25 def revertStandardError():
26     """Move stderr to stdout, and return the contents of the old stderr."""
27     errio = sys.stderr
28     if not isinstance(errio, StringIO):
29         return ''
30     sys.stderr = sys.stdout
31     errio.seek(0)
32     return errio.read()
33
34 def printError():
35     """Revert stderr to stdout, and print the contents of stderr"""
36     if isinstance(sys.stderr, StringIO):
37         print revertStandardError()
38
39 if __name__ == '__main__':
40     import atexit
41     atexit.register(printError)
42
43 import templates
44 from Cheetah.Template import Template
45 import validation
46 import cache_acls
47 from webcommon import State
48 import controls
49 from getafsgroups import getAfsGroupMembers
50 from invirt import database
51 from invirt.database import Machine, CDROM, session, connect, MachineAccess, Type, Autoinstall
52 from invirt.config import structs as config
53 from invirt.common import InvalidInput, CodeError
54
55 def pathSplit(path):
56     if path.startswith('/'):
57         path = path[1:]
58     i = path.find('/')
59     if i == -1:
60         i = len(path)
61     return path[:i], path[i:]
62
63 class Checkpoint:
64     def __init__(self):
65         self.start_time = time.time()
66         self.checkpoints = []
67
68     def checkpoint(self, s):
69         self.checkpoints.append((s, time.time()))
70
71     def __str__(self):
72         return ('Timing info:\n%s\n' %
73                 '\n'.join(['%s: %s' % (d, t - self.start_time) for
74                            (d, t) in self.checkpoints]))
75
76 checkpoint = Checkpoint()
77
78 def jquote(string):
79     return "'" + string.replace('\\', '\\\\').replace("'", "\\'").replace('\n', '\\n') + "'"
80
81 def helppopup(subj):
82     """Return HTML code for a (?) link to a specified help topic"""
83     return ('<span class="helplink"><a href="help?' +
84             cgi.escape(urllib.urlencode(dict(subject=subj, simple='true')))
85             +'" target="_blank" ' +
86             'onclick="return helppopup(' + cgi.escape(jquote(subj)) + ')">(?)</a></span>')
87
88 def makeErrorPre(old, addition):
89     if addition is None:
90         return
91     if old:
92         return old[:-6]  + '\n----\n' + str(addition) + '</pre>'
93     else:
94         return '<p>STDERR:</p><pre>' + str(addition) + '</pre>'
95
96 Template.database = database
97 Template.config = config
98 Template.helppopup = staticmethod(helppopup)
99 Template.err = None
100
101 class JsonDict:
102     """Class to store a dictionary that will be converted to JSON"""
103     def __init__(self, **kws):
104         self.data = kws
105         if 'err' in kws:
106             err = kws['err']
107             del kws['err']
108             self.addError(err)
109
110     def __str__(self):
111         return simplejson.dumps(self.data)
112
113     def addError(self, text):
114         """Add stderr text to be displayed on the website."""
115         self.data['err'] = \
116             makeErrorPre(self.data.get('err'), text)
117
118 class Defaults:
119     """Class to store default values for fields."""
120     memory = 256
121     disk = 4.0
122     cdrom = ''
123     autoinstall = ''
124     name = ''
125     description = ''
126     type = 'linux-hvm'
127
128     def __init__(self, max_memory=None, max_disk=None, **kws):
129         if max_memory is not None:
130             self.memory = min(self.memory, max_memory)
131         if max_disk is not None:
132             self.disk = min(self.disk, max_disk)
133         for key in kws:
134             setattr(self, key, kws[key])
135
136
137
138 DEFAULT_HEADERS = {'Content-Type': 'text/html'}
139
140 def invalidInput(op, username, fields, err, emsg):
141     """Print an error page when an InvalidInput exception occurs"""
142     d = dict(op=op, user=username, err_field=err.err_field,
143              err_value=str(err.err_value), stderr=emsg,
144              errorMessage=str(err))
145     return templates.invalid(searchList=[d])
146
147 def hasVnc(status):
148     """Does the machine with a given status list support VNC?"""
149     if status is None:
150         return False
151     for l in status:
152         if l[0] == 'device' and l[1][0] == 'vfb':
153             d = dict(l[1][1:])
154             return 'location' in d
155     return False
156
157 def parseCreate(username, state, fields):
158     kws = dict([(kw, fields.getfirst(kw)) for kw in 'name description owner memory disksize vmtype cdrom autoinstall'.split()])
159     validate = validation.Validate(username, state, strict=True, **kws)
160     return dict(contact=username, name=validate.name, description=validate.description, memory=validate.memory,
161                 disksize=validate.disksize, owner=validate.owner, machine_type=getattr(validate, 'vmtype', Defaults.type),
162                 cdrom=getattr(validate, 'cdrom', None),
163                 autoinstall=getattr(validate, 'autoinstall', None))
164
165 def create(username, state, path, fields):
166     """Handler for create requests."""
167     try:
168         parsed_fields = parseCreate(username, state, fields)
169         machine = controls.createVm(username, state, **parsed_fields)
170     except InvalidInput, err:
171         pass
172     else:
173         err = None
174     state.clear() #Changed global state
175     d = getListDict(username, state)
176     d['err'] = err
177     if err:
178         for field in fields.keys():
179             setattr(d['defaults'], field, fields.getfirst(field))
180     else:
181         d['new_machine'] = parsed_fields['name']
182     return templates.list(searchList=[d])
183
184
185 def getListDict(username, state):
186     """Gets the list of local variables used by list.tmpl."""
187     checkpoint.checkpoint('Starting')
188     machines = state.machines
189     checkpoint.checkpoint('Got my machines')
190     on = {}
191     has_vnc = {}
192     xmlist = state.xmlist
193     checkpoint.checkpoint('Got uptimes')
194     can_clone = 'ice3' not in state.xmlist_raw
195     for m in machines:
196         if m not in xmlist:
197             has_vnc[m] = 'Off'
198             m.uptime = None
199         else:
200             m.uptime = xmlist[m]['uptime']
201             if xmlist[m]['console']:
202                 has_vnc[m] = True
203             elif m.type.hvm:
204                 has_vnc[m] = "WTF?"
205             else:
206                 has_vnc[m] = "ParaVM"+helppopup("ParaVM Console")
207     max_memory = validation.maxMemory(username, state)
208     max_disk = validation.maxDisk(username)
209     checkpoint.checkpoint('Got max mem/disk')
210     defaults = Defaults(max_memory=max_memory,
211                         max_disk=max_disk,
212                         owner=username)
213     checkpoint.checkpoint('Got defaults')
214     def sortkey(machine):
215         return (machine.owner != username, machine.owner, machine.name)
216     machines = sorted(machines, key=sortkey)
217     d = dict(user=username,
218              cant_add_vm=validation.cantAddVm(username, state),
219              max_memory=max_memory,
220              max_disk=max_disk,
221              defaults=defaults,
222              machines=machines,
223              has_vnc=has_vnc,
224              can_clone=can_clone)
225     return d
226
227 def listVms(username, state, path, fields):
228     """Handler for list requests."""
229     checkpoint.checkpoint('Getting list dict')
230     d = getListDict(username, state)
231     checkpoint.checkpoint('Got list dict')
232     return templates.list(searchList=[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 getUser(environ):
683     """Return the current user based on the SSL environment variables"""
684     user = environ.get('REMOTE_USER')
685     if user is None:
686         return
687     
688     if environ.get('AUTH_TYPE') == 'Negotiate':
689         # Convert the krb5 principal into a krb4 username
690         if not user.endswith('@%s' % config.kerberos.realm):
691             return
692         else:
693             return user.split('@')[0].replace('/', '.')
694     else:
695         return user
696
697 def handler(username, state, path, fields):
698     operation, path = pathSplit(path)
699     if not operation:
700         operation = 'list'
701     print 'Starting', operation
702     fun = mapping.get(operation, badOperation)
703     return fun(username, state, path, fields)
704
705 class App:
706     def __init__(self, environ, start_response):
707         self.environ = environ
708         self.start = start_response
709
710         self.username = getUser(environ)
711         self.state = State(self.username)
712         self.state.environ = environ
713
714         random.seed() #sigh
715
716     def __iter__(self):
717         start_time = time.time()
718         database.clear_cache()
719         sys.stderr = StringIO()
720         fields = cgi.FieldStorage(fp=self.environ['wsgi.input'], environ=self.environ)
721         operation = self.environ.get('PATH_INFO', '')
722         if not operation:
723             self.start("301 Moved Permanently", [('Location', './')])
724             return
725         if self.username is None:
726             operation = 'unauth'
727
728         try:
729             checkpoint.checkpoint('Before')
730             output = handler(self.username, self.state, operation, fields)
731             checkpoint.checkpoint('After')
732
733             headers = dict(DEFAULT_HEADERS)
734             if isinstance(output, tuple):
735                 new_headers, output = output
736                 headers.update(new_headers)
737             e = revertStandardError()
738             if e:
739                 if hasattr(output, 'addError'):
740                     output.addError(e)
741                 else:
742                     # This only happens on redirects, so it'd be a pain to get
743                     # the message to the user.  Maybe in the response is useful.
744                     output = output + '\n\nstderr:\n' + e
745             output_string =  str(output)
746             checkpoint.checkpoint('output as a string')
747         except Exception, err:
748             if not fields.has_key('js'):
749                 if isinstance(err, InvalidInput):
750                     self.start('200 OK', [('Content-Type', 'text/html')])
751                     e = revertStandardError()
752                     yield str(invalidInput(operation, self.username, fields,
753                                            err, e))
754                     return
755             import traceback
756             self.start('500 Internal Server Error',
757                        [('Content-Type', 'text/html')])
758             e = revertStandardError()
759             s = show_error(operation, self.username, fields,
760                            err, e, traceback.format_exc())
761             yield str(s)
762             return
763         status = headers.setdefault('Status', '200 OK')
764         del headers['Status']
765         self.start(status, headers.items())
766         yield output_string
767         if fields.has_key('timedebug'):
768             yield '<pre>%s</pre>' % cgi.escape(str(checkpoint))
769
770 def constructor():
771     connect()
772     return App
773
774 def main():
775     from flup.server.fcgi_fork import WSGIServer
776     WSGIServer(constructor()).run()
777
778 if __name__ == '__main__':
779     main()