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