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

Last change on this file since 1736 was 1736, checked in by price, 16 years ago

update ParaVM/HVM help text

  • Property svn:executable set to *
File size: 27.5 KB
Line 
1#!/usr/bin/python
2"""Main CGI script for web interface"""
3
4import base64
5import cPickle
6import cgi
7import datetime
8import hmac
9import random
10import sha
11import simplejson
12import sys
13import time
14import urllib
15from StringIO import StringIO
16
17def revertStandardError():
18    """Move stderr to stdout, and return the contents of the old stderr."""
19    errio = sys.stderr
20    if not isinstance(errio, StringIO):
21        return ''
22    sys.stderr = sys.stdout
23    errio.seek(0)
24    return errio.read()
25
26def printError():
27    """Revert stderr to stdout, and print the contents of stderr"""
28    if isinstance(sys.stderr, StringIO):
29        print revertStandardError()
30
31if __name__ == '__main__':
32    import atexit
33    atexit.register(printError)
34
35import templates
36from Cheetah.Template import Template
37import validation
38import cache_acls
39from webcommon import State
40import controls
41from getafsgroups import getAfsGroupMembers
42from invirt import database
43from invirt.database import Machine, CDROM, session, connect, MachineAccess, Type, Autoinstall
44from invirt.config import structs as config
45from invirt.common import InvalidInput, CodeError
46
47def 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
55class 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
68checkpoint = Checkpoint()
69
70def jquote(string):
71    return "'" + string.replace('\\', '\\\\').replace("'", "\\'").replace('\n', '\\n') + "'"
72
73def 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
80def 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
88Template.database = database
89Template.config = config
90Template.helppopup = staticmethod(helppopup)
91Template.err = None
92
93class 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
110class 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
130DEFAULT_HEADERS = {'Content-Type': 'text/html'}
131
132def 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
139def 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
149def 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
157def 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
177def 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
220def 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
227def 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
268def 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
281def 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
303def 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
319def 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
348def 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
404def modify(username, state, path, fields):
405    """Handler for modifying attributes of a machine."""
406    try:
407        modify_dict = modifyDict(username, state, fields)
408    except InvalidInput, err:
409        result = None
410        machine = validation.Validate(username, state, machine_id=fields.getfirst('machine_id')).machine
411    else:
412        machine = modify_dict['machine']
413        result = 'Success!'
414        err = None
415    info_dict = infoDict(username, state, machine)
416    info_dict['err'] = err
417    if err:
418        for field in fields.keys():
419            setattr(info_dict['defaults'], field, fields.getfirst(field))
420    info_dict['result'] = result
421    return templates.info(searchList=[info_dict])
422
423
424def helpHandler(username, state, path, fields):
425    """Handler for help messages."""
426    simple = fields.getfirst('simple')
427    subjects = fields.getlist('subject')
428
429    help_mapping = {
430                    'Autoinstalls': """
431The autoinstaller builds a minimal Debian or Ubuntu system to run as a
432ParaVM.  You can access the resulting system by logging into the <a
433href="help?simple=true&subject=ParaVM+Console">serial console server</a>
434with your Kerberos tickets; there is no root password so sshd will
435refuse login.</p>
436
437<p>Under the covers, the autoinstaller uses our own patched version of
438xen-create-image, which is a tool based on debootstrap.  If you log
439into the serial console while the install is running, you can watch
440it.
441""",
442                    'ParaVM Console': """
443ParaVM machines do not support local console access over VNC.  To
444access the serial console of these machines, you can SSH with Kerberos
445to %s, using the name of the machine as your
446username.""" % config.console.hostname,
447                    'HVM/ParaVM': """
448HVM machines use the virtualization features of the processor, while
449ParaVM machines rely on a modified kernel to communicate directly with
450the hypervisor.  HVMs support boot CDs of any operating system, and
451the VNC console applet.  The three-minute autoinstaller produces
452ParaVMs.  ParaVMs typically are more efficient, and always support the
453console server.</p>
454
455<p>We recommend using a ParaVM when possible and an HVM when necessary.
456""",
457                    'CPU Weight': """
458Don't ask us!  We're as mystified as you are.""",
459                    'Owner': """
460The owner field is used to determine <a
461href="help?subject=Quotas">quotas</a>.  It must be the name of a
462locker that you are an AFS administrator of.  In particular, you or an
463AFS group you are a member of must have AFS rlidwka bits on the
464locker.  You can check who administers the LOCKER locker using the
465commands 'attach LOCKER; fs la /mit/LOCKER' on Athena.)  See also <a
466href="help?subject=Administrator">administrator</a>.""",
467                    'Administrator': """
468The administrator field determines who can access the console and
469power on and off the machine.  This can be either a user or a moira
470group.""",
471                    'Quotas': """
472Quotas are determined on a per-locker basis.  Each locker may have a
473maximum of 512 megabytes of active ram, 50 gigabytes of disk, and 4
474active machines.""",
475                    'Console': """
476<strong>Framebuffer:</strong> At a Linux boot prompt in your VM, try
477setting <tt>fb=false</tt> to disable the framebuffer.  If you don't,
478your machine will run just fine, but the applet's display of the
479console 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
498def badOperation(u, s, p, e):
499    """Function called when accessing an unknown URI."""
500    return ({'Status': '404 Not Found'}, 'Invalid operation.')
501
502def 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
599def 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
606def unauthFront(_, _2, _3, fields):
607    """Information for unauth'd users."""
608    return templates.unauth(searchList=[{'simple' : True}])
609
610def 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
622def throwError(_, __, ___, ____):
623    """Throw an error, to test the error-tracing mechanisms."""
624    raise RuntimeError("test of the emergency broadcast system")
625
626mapping = 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
638def 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
644def send_error_mail(subject, body):
645    import subprocess
646
647    to = config.web.errormail
648    mail = """To: %s
649From: root@%s
650Subject: %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
660def 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
672def 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
687def 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
695class 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
760def constructor():
761    connect()
762    return App
763
764def main():
765    from flup.server.fcgi_fork import WSGIServer
766    WSGIServer(constructor()).run()
767
768if __name__ == '__main__':
769    main()
Note: See TracBrowser for help on using the repository browser.