2 """Main CGI script for web interface"""
15 from StringIO import StringIO
17 def revertStandardError():
18 """Move stderr to stdout, and return the contents of the old stderr."""
20 if not isinstance(errio, StringIO):
22 sys.stderr = sys.stdout
27 """Revert stderr to stdout, and print the contents of stderr"""
28 if isinstance(sys.stderr, StringIO):
29 print revertStandardError()
31 if __name__ == '__main__':
33 atexit.register(printError)
36 from Cheetah.Template import Template
39 from webcommon import State
41 from getafsgroups import getAfsGroupMembers
42 from invirt import database
43 from invirt.database import Machine, CDROM, session, connect, MachineAccess, Type, Autoinstall
44 from invirt.config import structs as config
45 from invirt.common import InvalidInput, CodeError
48 if path.startswith('/'):
53 return path[:i], path[i:]
57 self.start_time = time.time()
60 def checkpoint(self, s):
61 self.checkpoints.append((s, time.time()))
64 return ('Timing info:\n%s\n' %
65 '\n'.join(['%s: %s' % (d, t - self.start_time) for
66 (d, t) in self.checkpoints]))
68 checkpoint = Checkpoint()
71 return "'" + string.replace('\\', '\\\\').replace("'", "\\'").replace('\n', '\\n') + "'"
74 """Return HTML code for a (?) link to a specified help topic"""
75 return ('<span class="helplink"><a href="help?' +
76 cgi.escape(urllib.urlencode(dict(subject=subj, simple='true')))
77 +'" target="_blank" ' +
78 'onclick="return helppopup(' + cgi.escape(jquote(subj)) + ')">(?)</a></span>')
80 def makeErrorPre(old, addition):
84 return old[:-6] + '\n----\n' + str(addition) + '</pre>'
86 return '<p>STDERR:</p><pre>' + str(addition) + '</pre>'
88 Template.database = database
89 Template.config = config
90 Template.helppopup = staticmethod(helppopup)
94 """Class to store a dictionary that will be converted to JSON"""
95 def __init__(self, **kws):
103 return simplejson.dumps(self.data)
105 def addError(self, text):
106 """Add stderr text to be displayed on the website."""
108 makeErrorPre(self.data.get('err'), text)
111 """Class to store default values for fields."""
120 def __init__(self, max_memory=None, max_disk=None, **kws):
121 if max_memory is not None:
122 self.memory = min(self.memory, max_memory)
123 if max_disk is not None:
124 self.max_disk = min(self.disk, max_disk)
126 setattr(self, key, kws[key])
130 DEFAULT_HEADERS = {'Content-Type': 'text/html'}
132 def invalidInput(op, username, fields, err, emsg):
133 """Print an error page when an InvalidInput exception occurs"""
134 d = dict(op=op, user=username, err_field=err.err_field,
135 err_value=str(err.err_value), stderr=emsg,
136 errorMessage=str(err))
137 return templates.invalid(searchList=[d])
140 """Does the machine with a given status list support VNC?"""
144 if l[0] == 'device' and l[1][0] == 'vfb':
146 return 'location' in d
149 def parseCreate(username, state, fields):
150 kws = dict([(kw, fields.getfirst(kw)) for kw in 'name description owner memory disksize vmtype cdrom autoinstall'.split()])
151 validate = validation.Validate(username, state, strict=True, **kws)
152 return dict(contact=username, name=validate.name, description=validate.description, memory=validate.memory,
153 disksize=validate.disksize, owner=validate.owner, machine_type=validate.vmtype,
154 cdrom=getattr(validate, 'cdrom', None),
155 autoinstall=getattr(validate, 'autoinstall', None))
157 def create(username, state, path, fields):
158 """Handler for create requests."""
160 parsed_fields = parseCreate(username, state, fields)
161 machine = controls.createVm(username, state, **parsed_fields)
162 except InvalidInput, err:
166 state.clear() #Changed global state
167 d = getListDict(username, state)
170 for field in fields.keys():
171 setattr(d['defaults'], field, fields.getfirst(field))
173 d['new_machine'] = parsed_fields['name']
174 return templates.list(searchList=[d])
177 def getListDict(username, state):
178 """Gets the list of local variables used by list.tmpl."""
179 checkpoint.checkpoint('Starting')
180 machines = state.machines
181 checkpoint.checkpoint('Got my machines')
184 xmlist = state.xmlist
185 checkpoint.checkpoint('Got uptimes')
186 can_clone = 'ice3' not in state.xmlist_raw
192 m.uptime = xmlist[m]['uptime']
193 if xmlist[m]['console']:
198 has_vnc[m] = "ParaVM"+helppopup("ParaVM Console")
199 max_memory = validation.maxMemory(username, state)
200 max_disk = validation.maxDisk(username)
201 checkpoint.checkpoint('Got max mem/disk')
202 defaults = Defaults(max_memory=max_memory,
206 checkpoint.checkpoint('Got defaults')
207 def sortkey(machine):
208 return (machine.owner != username, machine.owner, machine.name)
209 machines = sorted(machines, key=sortkey)
210 d = dict(user=username,
211 cant_add_vm=validation.cantAddVm(username, state),
212 max_memory=max_memory,
220 def listVms(username, state, path, fields):
221 """Handler for list requests."""
222 checkpoint.checkpoint('Getting list dict')
223 d = getListDict(username, state)
224 checkpoint.checkpoint('Got list dict')
225 return templates.list(searchList=[d])
227 def vnc(username, state, path, fields):
230 Note that due to same-domain restrictions, the applet connects to
231 the webserver, which needs to forward those requests to the xen
232 server. The Xen server runs another proxy that (1) authenticates
233 and (2) finds the correct port for the VM.
235 You might want iptables like:
237 -t nat -A PREROUTING -s ! 18.181.0.60 -i eth1 -p tcp -m tcp \
238 --dport 10003 -j DNAT --to-destination 18.181.0.60:10003
239 -t nat -A POSTROUTING -d 18.181.0.60 -o eth1 -p tcp -m tcp \
240 --dport 10003 -j SNAT --to-source 18.187.7.142
241 -A FORWARD -d 18.181.0.60 -i eth1 -o eth1 -p tcp -m tcp \
242 --dport 10003 -j ACCEPT
244 Remember to enable iptables!
245 echo 1 > /proc/sys/net/ipv4/ip_forward
247 machine = validation.Validate(username, state, machine_id=fields.getfirst('machine_id')).machine
249 token = controls.vnctoken(machine)
250 host = controls.listHost(machine)
252 port = 10003 + [h.hostname for h in config.hosts].index(host)
256 status = controls.statusInfo(machine)
257 has_vnc = hasVnc(status)
259 d = dict(user=username,
263 hostname=state.environ.get('SERVER_NAME', 'localhost'),
266 return templates.vnc(searchList=[d])
268 def getHostname(nic):
269 """Find the hostname associated with a NIC.
271 XXX this should be merged with the similar logic in DNS and DHCP.
273 if nic.hostname and '.' in nic.hostname:
276 return nic.machine.name + '.' + config.dns.domains[0]
281 def getNicInfo(data_dict, machine):
282 """Helper function for info, get data on nics for a machine.
284 Modifies data_dict to include the relevant data, and returns a list
285 of (key, name) pairs to display "name: data_dict[key]" to the user.
287 data_dict['num_nics'] = len(machine.nics)
288 nic_fields_template = [('nic%s_hostname', 'NIC %s Hostname'),
289 ('nic%s_mac', 'NIC %s MAC Addr'),
290 ('nic%s_ip', 'NIC %s IP'),
293 for i in range(len(machine.nics)):
294 nic_fields.extend([(x % i, y % i) for x, y in nic_fields_template])
296 data_dict['nic%s_hostname' % i] = getHostname(machine.nics[i])
297 data_dict['nic%s_mac' % i] = machine.nics[i].mac_addr
298 data_dict['nic%s_ip' % i] = machine.nics[i].ip
299 if len(machine.nics) == 1:
300 nic_fields = [(x, y.replace('NIC 0 ', '')) for x, y in nic_fields]
303 def getDiskInfo(data_dict, machine):
304 """Helper function for info, get data on disks for a machine.
306 Modifies data_dict to include the relevant data, and returns a list
307 of (key, name) pairs to display "name: data_dict[key]" to the user.
309 data_dict['num_disks'] = len(machine.disks)
310 disk_fields_template = [('%s_size', '%s size')]
312 for disk in machine.disks:
313 name = disk.guest_device_name
314 disk_fields.extend([(x % name, y % name) for x, y in
315 disk_fields_template])
316 data_dict['%s_size' % name] = "%0.1f GiB" % (disk.size / 1024.)
319 def command(username, state, path, fields):
320 """Handler for running commands like boot and delete on a VM."""
321 back = fields.getfirst('back')
323 d = controls.commandResult(username, state, fields)
324 if d['command'] == 'Delete VM':
326 except InvalidInput, err:
329 print >> sys.stderr, err
334 return templates.command(searchList=[d])
336 state.clear() #Changed global state
337 d = getListDict(username, state)
339 return templates.list(searchList=[d])
341 machine = validation.Validate(username, state, machine_id=fields.getfirst('machine_id')).machine
342 return ({'Status': '303 See Other',
343 'Location': 'info?machine_id=%d' % machine.machine_id},
344 "You shouldn't see this message.")
346 raise InvalidInput('back', back, 'Not a known back page.')
348 def modifyDict(username, state, fields):
349 """Modify a machine as specified by CGI arguments.
351 Return a list of local variables for modify.tmpl.
356 kws = dict([(kw, fields.getfirst(kw)) for kw in 'machine_id owner admin contact name description memory vmtype disksize'.split()])
357 validate = validation.Validate(username, state, **kws)
358 machine = validate.machine
359 oldname = machine.name
361 if hasattr(validate, 'memory'):
362 machine.memory = validate.memory
364 if hasattr(validate, 'vmtype'):
365 machine.type = validate.vmtype
367 if hasattr(validate, 'disksize'):
368 disksize = validate.disksize
369 disk = machine.disks[0]
370 if disk.size != disksize:
371 olddisk[disk.guest_device_name] = disksize
373 session.save_or_update(disk)
376 if hasattr(validate, 'owner') and validate.owner != machine.owner:
377 machine.owner = validate.owner
379 if hasattr(validate, 'name'):
380 machine.name = validate.name
381 if hasattr(validate, 'description'):
382 machine.description = validate.description
383 if hasattr(validate, 'admin') and validate.admin != machine.administrator:
384 machine.administrator = validate.admin
386 if hasattr(validate, 'contact'):
387 machine.contact = validate.contact
389 session.save_or_update(machine)
391 cache_acls.refreshMachine(machine)
396 for diskname in olddisk:
397 controls.resizeDisk(oldname, diskname, str(olddisk[diskname]))
398 if hasattr(validate, 'name'):
399 controls.renameMachine(machine, oldname, validate.name)
400 return dict(user=username,
404 def modify(username, state, path, fields):
405 """Handler for modifying attributes of a machine."""
407 modify_dict = modifyDict(username, state, fields)
408 except InvalidInput, err:
410 machine = validation.Validate(username, state, machine_id=fields.getfirst('machine_id')).machine
412 machine = modify_dict['machine']
415 info_dict = infoDict(username, state, machine)
416 info_dict['err'] = err
418 for field in fields.keys():
419 setattr(info_dict['defaults'], field, fields.getfirst(field))
420 info_dict['result'] = result
421 return templates.info(searchList=[info_dict])
424 def helpHandler(username, state, path, fields):
425 """Handler for help messages."""
426 simple = fields.getfirst('simple')
427 subjects = fields.getlist('subject')
431 The autoinstaller builds a minimal Debian or Ubuntu system to run as a
432 ParaVM. You can access the resulting system by logging into the <a
433 href="help?simple=true&subject=ParaVM+Console">serial console server</a>
434 with your Kerberos tickets; there is no root password and sshd will
437 <p>Under the covers the autoinstaller uses our own patched version of
438 xen-create-image, which is a tool based on debootstrap. If you're
439 quick in logging into the serial console, you can see it running.
441 'ParaVM Console': """
442 ParaVM machines do not support local console access over VNC. To
443 access the serial console of these machines, you can SSH with Kerberos
444 to %s, using the name of the machine as your
445 username.""" % config.console.hostname,
447 HVM machines use the virtualization features of the processor, while
448 ParaVM machines use Xen's emulation of virtualization features. You
449 want an HVM virtualized machine.""",
451 Don't ask us! We're as mystified as you are.""",
453 The owner field is used to determine <a
454 href="help?subject=Quotas">quotas</a>. It must be the name of a
455 locker that you are an AFS administrator of. In particular, you or an
456 AFS group you are a member of must have AFS rlidwka bits on the
457 locker. You can check who administers the LOCKER locker using the
458 commands 'attach LOCKER; fs la /mit/LOCKER' on Athena.) See also <a
459 href="help?subject=Administrator">administrator</a>.""",
461 The administrator field determines who can access the console and
462 power on and off the machine. This can be either a user or a moira
465 Quotas are determined on a per-locker basis. Each locker may have a
466 maximum of 512 megabytes of active ram, 50 gigabytes of disk, and 4
469 <strong>Framebuffer:</strong> At a Linux boot prompt in your VM, try
470 setting <tt>fb=false</tt> to disable the framebuffer. If you don't,
471 your machine will run just fine, but the applet's display of the
472 console will suffer artifacts.
475 <strong>Windows Vista:</strong> The Vista image is licensed for all MIT students and will automatically activate off the network; see <a href="/static/msca-email.txt">the licensing confirmation e-mail</a> for details. The installer req uires 512 MB RAM and at least 7.5 GB disk space (15 GB or more recommended).<br>
476 <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.
481 subjects = sorted(help_mapping.keys())
483 d = dict(user=username,
486 mapping=help_mapping)
488 return templates.help(searchList=[d])
491 def badOperation(u, s, p, e):
492 """Function called when accessing an unknown URI."""
493 return ({'Status': '404 Not Found'}, 'Invalid operation.')
495 def infoDict(username, state, machine):
496 """Get the variables used by info.tmpl."""
497 status = controls.statusInfo(machine)
498 checkpoint.checkpoint('Getting status info')
499 has_vnc = hasVnc(status)
501 main_status = dict(name=machine.name,
502 memory=str(machine.memory))
506 main_status = dict(status[1:])
507 main_status['host'] = controls.listHost(machine)
508 start_time = float(main_status.get('start_time', 0))
509 uptime = datetime.timedelta(seconds=int(time.time()-start_time))
510 cpu_time_float = float(main_status.get('cpu_time', 0))
511 cputime = datetime.timedelta(seconds=int(cpu_time_float))
512 checkpoint.checkpoint('Status')
513 display_fields = """name uptime memory state cpu_weight on_reboot
514 on_poweroff on_crash on_xend_start on_xend_stop bootloader""".split()
515 display_fields = [('name', 'Name'),
516 ('description', 'Description'),
518 ('administrator', 'Administrator'),
519 ('contact', 'Contact'),
522 ('uptime', 'uptime'),
523 ('cputime', 'CPU usage'),
524 ('host', 'Hosted on'),
527 ('state', 'state (xen format)'),
528 ('cpu_weight', 'CPU weight'+helppopup('CPU Weight')),
529 ('on_reboot', 'Action on VM reboot'),
530 ('on_poweroff', 'Action on VM poweroff'),
531 ('on_crash', 'Action on VM crash'),
532 ('on_xend_start', 'Action on Xen start'),
533 ('on_xend_stop', 'Action on Xen stop'),
534 ('bootloader', 'Bootloader options'),
538 machine_info['name'] = machine.name
539 machine_info['description'] = machine.description
540 machine_info['type'] = machine.type.hvm and 'HVM' or 'ParaVM'
541 machine_info['owner'] = machine.owner
542 machine_info['administrator'] = machine.administrator
543 machine_info['contact'] = machine.contact
545 nic_fields = getNicInfo(machine_info, machine)
546 nic_point = display_fields.index('NIC_INFO')
547 display_fields = (display_fields[:nic_point] + nic_fields +
548 display_fields[nic_point+1:])
550 disk_fields = getDiskInfo(machine_info, machine)
551 disk_point = display_fields.index('DISK_INFO')
552 display_fields = (display_fields[:disk_point] + disk_fields +
553 display_fields[disk_point+1:])
555 main_status['memory'] += ' MiB'
556 for field, disp in display_fields:
557 if field in ('uptime', 'cputime') and locals()[field] is not None:
558 fields.append((disp, locals()[field]))
559 elif field in machine_info:
560 fields.append((disp, machine_info[field]))
561 elif field in main_status:
562 fields.append((disp, main_status[field]))
565 #fields.append((disp, None))
567 checkpoint.checkpoint('Got fields')
570 max_mem = validation.maxMemory(machine.owner, state, machine, False)
571 checkpoint.checkpoint('Got mem')
572 max_disk = validation.maxDisk(machine.owner, machine)
573 defaults = Defaults()
574 for name in 'machine_id name description administrator owner memory contact'.split():
575 setattr(defaults, name, getattr(machine, name))
576 defaults.type = machine.type.type_id
577 defaults.disk = "%0.2f" % (machine.disks[0].size/1024.)
578 checkpoint.checkpoint('Got defaults')
579 d = dict(user=username,
580 on=status is not None,
588 owner_help=helppopup("Owner"),
592 def info(username, state, path, fields):
593 """Handler for info on a single VM."""
594 machine = validation.Validate(username, state, machine_id=fields.getfirst('machine_id')).machine
595 d = infoDict(username, state, machine)
596 checkpoint.checkpoint('Got infodict')
597 return templates.info(searchList=[d])
599 def unauthFront(_, _2, _3, fields):
600 """Information for unauth'd users."""
601 return templates.unauth(searchList=[{'simple' : True}])
603 def admin(username, state, path, fields):
605 return ({'Status': '303 See Other',
606 'Location': 'admin/'},
607 "You shouldn't see this message.")
608 if not username in getAfsGroupMembers(config.web.adminacl, 'athena.mit.edu'):
609 raise InvalidInput('username', username,
610 'Not in admin group %s.' % config.web.adminacl)
611 newstate = State(username, isadmin=True)
612 newstate.environ = state.environ
613 return handler(username, newstate, path, fields)
615 def throwError(_, __, ___, ____):
616 """Throw an error, to test the error-tracing mechanisms."""
617 raise RuntimeError("test of the emergency broadcast system")
619 mapping = dict(list=listVms,
629 errortest=throwError)
631 def printHeaders(headers):
632 """Print a dictionary as HTTP headers."""
633 for key, value in headers.iteritems():
634 print '%s: %s' % (key, value)
637 def send_error_mail(subject, body):
640 to = config.web.errormail
646 """ % (to, config.web.hostname, subject, body)
647 p = subprocess.Popen(['/usr/sbin/sendmail', to], stdin=subprocess.PIPE)
652 def show_error(op, username, fields, err, emsg, traceback):
653 """Print an error page when an exception occurs"""
654 d = dict(op=op, user=username, fields=fields,
655 errorMessage=str(err), stderr=emsg, traceback=traceback)
656 details = templates.error_raw(searchList=[d])
657 exclude = config.web.errormail_exclude
658 if username not in exclude and '*' not in exclude:
659 send_error_mail('xvm error on %s for %s: %s' % (op, username, err),
661 d['details'] = details
662 return templates.error(searchList=[d])
664 def getUser(environ):
665 """Return the current user based on the SSL environment variables"""
666 user = environ.get('REMOTE_USER')
670 if environ.get('AUTH_TYPE') == 'Negotiate':
671 # Convert the krb5 principal into a krb4 username
672 if not user.endswith('@%s' % config.authn[0].realm):
675 return user.split('@')[0].replace('/', '.')
679 def handler(username, state, path, fields):
680 operation, path = pathSplit(path)
683 print 'Starting', operation
684 fun = mapping.get(operation, badOperation)
685 return fun(username, state, path, fields)
688 def __init__(self, environ, start_response):
689 self.environ = environ
690 self.start = start_response
692 self.username = getUser(environ)
693 self.state = State(self.username)
694 self.state.environ = environ
699 start_time = time.time()
700 database.clear_cache()
701 sys.stderr = StringIO()
702 fields = cgi.FieldStorage(fp=self.environ['wsgi.input'], environ=self.environ)
703 operation = self.environ.get('PATH_INFO', '')
705 self.start("301 Moved Permanently", [('Location', './')])
707 if self.username is None:
711 checkpoint.checkpoint('Before')
712 output = handler(self.username, self.state, operation, fields)
713 checkpoint.checkpoint('After')
715 headers = dict(DEFAULT_HEADERS)
716 if isinstance(output, tuple):
717 new_headers, output = output
718 headers.update(new_headers)
719 e = revertStandardError()
721 if hasattr(output, 'addError'):
724 # This only happens on redirects, so it'd be a pain to get
725 # the message to the user. Maybe in the response is useful.
726 output = output + '\n\nstderr:\n' + e
727 output_string = str(output)
728 checkpoint.checkpoint('output as a string')
729 except Exception, err:
730 if not fields.has_key('js'):
731 if isinstance(err, InvalidInput):
732 self.start('200 OK', [('Content-Type', 'text/html')])
733 e = revertStandardError()
734 yield str(invalidInput(operation, self.username, fields,
738 self.start('500 Internal Server Error',
739 [('Content-Type', 'text/html')])
740 e = revertStandardError()
741 s = show_error(operation, self.username, fields,
742 err, e, traceback.format_exc())
745 status = headers.setdefault('Status', '200 OK')
746 del headers['Status']
747 self.start(status, headers.items())
749 if fields.has_key('timedebug'):
750 yield '<pre>%s</pre>' % cgi.escape(str(checkpoint))
757 from flup.server.fcgi_fork import WSGIServer
758 WSGIServer(constructor()).run()
760 if __name__ == '__main__':