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