source: package_branches/invirt-web/cherrypy/code/main.py @ 2451

Last change on this file since 2451 was 2450, checked in by ecprice, 15 years ago

Clear stale fds out of cache in ajaxterm

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