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 os
  10 import sha
  11 import simplejson
  12 import sys
  13 import time
  14 from StringIO import StringIO
  15
  16 def revertStandardError():
  17     """Move stderr to stdout, and return the contents of the old stderr."""
  18     errio = sys.stderr
  19     if not isinstance(errio, StringIO):
  20         return None
  21     sys.stderr = sys.stdout
  22     errio.seek(0)
  23     return errio.read()
  24
  25 def printError():
  26     """Revert stderr to stdout, and print the contents of stderr"""
  27     if isinstance(sys.stderr, StringIO):
  28         print revertStandardError()
  29
  30 if __name__ == '__main__':
  31     import atexit
  32     atexit.register(printError)
  33     sys.stderr = StringIO()
  34
  35 sys.path.append('/home/ecprice/.local/lib/python2.5/site-packages')
  36
  37 import templates
  38 from Cheetah.Template import Template
  39 from sipb_xen_database import Machine, CDROM, ctx, connect
  40 import validation
  41 from webcommon import InvalidInput, CodeError, g
  42 import controls
  43
  44 class Checkpoint:
  45     def __init__(self):
  46         self.start_time = time.time()
  47         self.checkpoints = []
  48
  49     def checkpoint(self, s):
  50         self.checkpoints.append((s, time.time()))
  51
  52     def __str__(self):
  53         return ('Timing info:\n%s\n' %
  54                 '\n'.join(['%s: %s' % (d, t - self.start_time) for
  55                            (d, t) in self.checkpoints]))
  56
  57 checkpoint = Checkpoint()
  58
  59
  60 def helppopup(subj):
  61     """Return HTML code for a (?) link to a specified help topic"""
  62     return ('<span class="helplink"><a href="help?subject=' + subj +
  63             '&amp;simple=true" target="_blank" ' +
  64             'onclick="return helppopup(\'' + subj + '\')">(?)</a></span>')
  65
  66 def makeErrorPre(old, addition):
  67     if addition is None:
  68         return
  69     if old:
  70         return old[:-6]  + '\n----\n' + str(addition) + '</pre>'
  71     else:
  72         return '<p>STDERR:</p><pre>' + str(addition) + '</pre>'
  73
  74 Template.helppopup = staticmethod(helppopup)
  75 Template.err = None
  76
  77 class JsonDict:
  78     """Class to store a dictionary that will be converted to JSON"""
  79     def __init__(self, **kws):
  80         self.data = kws
  81         if 'err' in kws:
  82             err = kws['err']
  83             del kws['err']
  84             self.addError(err)
  85
  86     def __str__(self):
  87         return simplejson.dumps(self.data)
  88
  89     def addError(self, text):
  90         """Add stderr text to be displayed on the website."""
  91         self.data['err'] = \
  92             makeErrorPre(self.data.get('err'), text)
  93
  94 class Defaults:
  95     """Class to store default values for fields."""
  96     memory = 256
  97     disk = 4.0
  98     cdrom = ''
  99     name = ''
 100     vmtype = 'hvm'
 101     def __init__(self, max_memory=None, max_disk=None, **kws):
 102         if max_memory is not None:
 103             self.memory = min(self.memory, max_memory)
 104         if max_disk is not None:
 105             self.max_disk = min(self.disk, max_disk)
 106         for key in kws:
 107             setattr(self, key, kws[key])
 108
 109
 110
 111 DEFAULT_HEADERS = {'Content-Type': 'text/html'}
 112
 113 def error(op, user, fields, err, emsg):
 114     """Print an error page when a CodeError occurs"""
 115     d = dict(op=op, user=user, errorMessage=str(err),
 116              stderr=emsg)
 117     return templates.error(searchList=[d])
 118
 119 def invalidInput(op, user, fields, err, emsg):
 120     """Print an error page when an InvalidInput exception occurs"""
 121     d = dict(op=op, user=user, err_field=err.err_field,
 122              err_value=str(err.err_value), stderr=emsg,
 123              errorMessage=str(err))
 124     return templates.invalid(searchList=[d])
 125
 126 def hasVnc(status):
 127     """Does the machine with a given status list support VNC?"""
 128     if status is None:
 129         return False
 130     for l in status:
 131         if l[0] == 'device' and l[1][0] == 'vfb':
 132             d = dict(l[1][1:])
 133             return 'location' in d
 134     return False
 135
 136 def parseCreate(user, fields):
 137     name = fields.getfirst('name')
 138     if not validation.validMachineName(name):
 139         raise InvalidInput('name', name, 'You must provide a machine name.')
 140     name = name.lower()
 141
 142     if Machine.get_by(name=name):
 143         raise InvalidInput('name', name,
 144                            "Name already exists.")
 145
 146     owner = validation.testOwner(user, fields.getfirst('owner'))
 147
 148     memory = fields.getfirst('memory')
 149     memory = validation.validMemory(user, memory, on=True)
 150
 151     disk_size = fields.getfirst('disk')
 152     disk_size = validation.validDisk(user, disk_size)
 153
 154     vm_type = fields.getfirst('vmtype')
 155     if vm_type not in ('hvm', 'paravm'):
 156         raise CodeError("Invalid vm type '%s'"  % vm_type)
 157     is_hvm = (vm_type == 'hvm')
 158
 159     cdrom = fields.getfirst('cdrom')
 160     if cdrom is not None and not CDROM.get(cdrom):
 161         raise CodeError("Invalid cdrom type '%s'" % cdrom)
 162     return dict(contact=user, name=name, memory=memory, disk_size=disk_size,
 163                 owner=owner, is_hvm=is_hvm, cdrom=cdrom)
 164
 165 def create(user, fields):
 166     """Handler for create requests."""
 167     try:
 168         parsed_fields = parseCreate(user, fields)
 169         machine = controls.createVm(**parsed_fields)
 170     except InvalidInput, err:
 171         pass
 172     else:
 173         err = None
 174     g.clear() #Changed global state
 175     d = getListDict(user)
 176     d['err'] = err
 177     if err:
 178         for field in fields.keys():
 179             setattr(d['defaults'], field, fields.getfirst(field))
 180     else:
 181         d['new_machine'] = parsed_fields['name']
 182     return templates.list(searchList=[d])
 183
 184
 185 def getListDict(user):
 186     machines = [m for m in Machine.select()
 187                 if validation.haveAccess(user, m)]
 188     checkpoint.checkpoint('Got my machines')
 189     on = {}
 190     has_vnc = {}
 191     on = g.uptimes
 192     checkpoint.checkpoint('Got uptimes')
 193     for m in machines:
 194         m.uptime = g.uptimes.get(m)
 195         if not on[m]:
 196             has_vnc[m] = 'Off'
 197         elif m.type.hvm:
 198             has_vnc[m] = True
 199         else:
 200             has_vnc[m] = "ParaVM"+helppopup("paravm_console")
 201     max_memory = validation.maxMemory(user)
 202     max_disk = validation.maxDisk(user)
 203     checkpoint.checkpoint('Got max mem/disk')
 204     defaults = Defaults(max_memory=max_memory,
 205                         max_disk=max_disk,
 206                         owner=user,
 207                         cdrom='gutsy-i386')
 208     checkpoint.checkpoint('Got defaults')
 209     d = dict(user=user,
 210              cant_add_vm=validation.cantAddVm(user),
 211              max_memory=max_memory,
 212              max_disk=max_disk,
 213              defaults=defaults,
 214              machines=machines,
 215              has_vnc=has_vnc,
 216              uptimes=g.uptimes,
 217              cdroms=CDROM.select())
 218     return d
 219
 220 def listVms(user, fields):
 221     """Handler for list requests."""
 222     checkpoint.checkpoint('Getting list dict')
 223     d = getListDict(user)
 224     checkpoint.checkpoint('Got list dict')
 225     return templates.list(searchList=[d])
 226
 227 def vnc(user, fields):
 228     """VNC applet page.
 229
 230     Note that due to same-domain restrictions, the applet connects to
 231     the webserver, which needs to forward those requests to the xen
 232     server.  The Xen server runs another proxy that (1) authenticates
 233     and (2) finds the correct port for the VM.
 234
 235     You might want iptables like:
 236
 237     -t nat -A PREROUTING -s ! 18.181.0.60 -i eth1 -p tcp -m tcp \
 238       --dport 10003 -j DNAT --to-destination 18.181.0.60:10003
 239     -t nat -A POSTROUTING -d 18.181.0.60 -o eth1 -p tcp -m tcp \
 240       --dport 10003 -j SNAT --to-source 18.187.7.142
 241     -A FORWARD -d 18.181.0.60 -i eth1 -o eth1 -p tcp -m tcp \
 242       --dport 10003 -j ACCEPT
 243
 244     Remember to enable iptables!
 245     echo 1 > /proc/sys/net/ipv4/ip_forward
 246     """
 247     machine = validation.testMachineId(user, fields.getfirst('machine_id'))
 248
 249     TOKEN_KEY = "0M6W0U1IXexThi5idy8mnkqPKEq1LtEnlK/pZSn0cDrN"
 250
 251     data = {}
 252     data["user"] = user
 253     data["machine"] = machine.name
 254     data["expires"] = time.time()+(5*60)
 255     pickled_data = cPickle.dumps(data)
 256     m = hmac.new(TOKEN_KEY, digestmod=sha)
 257     m.update(pickled_data)
 258     token = {'data': pickled_data, 'digest': m.digest()}
 259     token = cPickle.dumps(token)
 260     token = base64.urlsafe_b64encode(token)
 261
 262     status = controls.statusInfo(machine)
 263     has_vnc = hasVnc(status)
 264
 265     d = dict(user=user,
 266              on=status,
 267              has_vnc=has_vnc,
 268              machine=machine,
 269              hostname=os.environ.get('SERVER_NAME', 'localhost'),
 270              authtoken=token)
 271     return templates.vnc(searchList=[d])
 272
 273 def getHostname(nic):
 274     if nic.hostname and '.' in nic.hostname:
 275         return nic.hostname
 276     elif nic.machine:
 277         return nic.machine.name + '.servers.csail.mit.edu'
 278     else:
 279         return None
 280
 281
 282 def getNicInfo(data_dict, machine):
 283     """Helper function for info, get data on nics for a machine.
 284
 285     Modifies data_dict to include the relevant data, and returns a list
 286     of (key, name) pairs to display "name: data_dict[key]" to the user.
 287     """
 288     data_dict['num_nics'] = len(machine.nics)
 289     nic_fields_template = [('nic%s_hostname', 'NIC %s Hostname'),
 290                            ('nic%s_mac', 'NIC %s MAC Addr'),
 291                            ('nic%s_ip', 'NIC %s IP'),
 292                            ]
 293     nic_fields = []
 294     for i in range(len(machine.nics)):
 295         nic_fields.extend([(x % i, y % i) for x, y in nic_fields_template])
 296         if not i:
 297             data_dict['nic%s_hostname' % i] = getHostname(machine.nics[i])
 298         data_dict['nic%s_mac' % i] = machine.nics[i].mac_addr
 299         data_dict['nic%s_ip' % i] = machine.nics[i].ip
 300     if len(machine.nics) == 1:
 301         nic_fields = [(x, y.replace('NIC 0 ', '')) for x, y in nic_fields]
 302     return nic_fields
 303
 304 def getDiskInfo(data_dict, machine):
 305     """Helper function for info, get data on disks for a machine.
 306
 307     Modifies data_dict to include the relevant data, and returns a list
 308     of (key, name) pairs to display "name: data_dict[key]" to the user.
 309     """
 310     data_dict['num_disks'] = len(machine.disks)
 311     disk_fields_template = [('%s_size', '%s size')]
 312     disk_fields = []
 313     for disk in machine.disks:
 314         name = disk.guest_device_name
 315         disk_fields.extend([(x % name, y % name) for x, y in
 316                             disk_fields_template])
 317         data_dict['%s_size' % name] = "%0.1f GiB" % (disk.size / 1024.)
 318     return disk_fields
 319
 320 def command(user, fields):
 321     """Handler for running commands like boot and delete on a VM."""
 322     back = fields.getfirst('back')
 323     try:
 324         d = controls.commandResult(user, fields)
 325         if d['command'] == 'Delete VM':
 326             back = 'list'
 327     except InvalidInput, err:
 328         if not back:
 329             raise
 330         print >> sys.stderr, err
 331         result = None
 332     else:
 333         result = 'Success!'
 334         if not back:
 335             return templates.command(searchList=[d])
 336     if back == 'list':
 337         g.clear() #Changed global state
 338         d = getListDict(user)
 339         d['result'] = result
 340         return templates.list(searchList=[d])
 341     elif back == 'info':
 342         machine = validation.testMachineId(user, fields.getfirst('machine_id'))
 343         d = infoDict(user, machine)
 344         d['result'] = result
 345         return templates.info(searchList=[d])
 346     else:
 347         raise InvalidInput
 348     ('back', back, 'Not a known back page.')
 349
 350 def modifyDict(user, fields):
 351     olddisk = {}
 352     transaction = ctx.current.create_transaction()
 353     try:
 354         machine = validation.testMachineId(user, fields.getfirst('machine_id'))
 355         owner = validation.testOwner(user, fields.getfirst('owner'), machine)
 356         admin = validation.testAdmin(user, fields.getfirst('administrator'),
 357                                      machine)
 358         contact = validation.testContact(user, fields.getfirst('contact'),
 359                                          machine)
 360         name = validation.testName(user, fields.getfirst('name'), machine)
 361         oldname = machine.name
 362         command = "modify"
 363
 364         memory = fields.getfirst('memory')
 365         if memory is not None:
 366             memory = validation.validMemory(user, memory, machine, on=False)
 367             machine.memory = memory
 368
 369         disksize = validation.testDisk(user, fields.getfirst('disk'))
 370         if disksize is not None:
 371             disksize = validation.validDisk(user, disksize, machine)
 372             disk = machine.disks[0]
 373             if disk.size != disksize:
 374                 olddisk[disk.guest_device_name] = disksize
 375                 disk.size = disksize
 376                 ctx.current.save(disk)
 377
 378         if owner is not None:
 379             machine.owner = owner
 380         if name is not None:
 381             machine.name = name
 382         if admin is not None:
 383             machine.administrator = admin
 384         if contact is not None:
 385             machine.contact = contact
 386
 387         ctx.current.save(machine)
 388         transaction.commit()
 389     except:
 390         transaction.rollback()
 391         raise
 392     for diskname in olddisk:
 393         controls.resizeDisk(oldname, diskname, str(olddisk[diskname]))
 394     if name is not None:
 395         controls.renameMachine(machine, oldname, name)
 396     return dict(user=user,
 397                 command=command,
 398                 machine=machine)
 399
 400 def modify(user, fields):
 401     """Handler for modifying attributes of a machine."""
 402     try:
 403         modify_dict = modifyDict(user, fields)
 404     except InvalidInput, err:
 405         result = None
 406         machine = validation.testMachineId(user, fields.getfirst('machine_id'))
 407     else:
 408         machine = modify_dict['machine']
 409         result = 'Success!'
 410         err = None
 411     info_dict = infoDict(user, machine)
 412     info_dict['err'] = err
 413     if err:
 414         for field in fields.keys():
 415             setattr(info_dict['defaults'], field, fields.getfirst(field))
 416     info_dict['result'] = result
 417     return templates.info(searchList=[info_dict])
 418
 419
 420 def helpHandler(user, fields):
 421     """Handler for help messages."""
 422     simple = fields.getfirst('simple')
 423     subjects = fields.getlist('subject')
 424
 425     help_mapping = dict(paravm_console="""
 426 ParaVM machines do not support console access over VNC.  To access
 427 these machines, you either need to boot with a liveCD and ssh in or
 428 hope that the sipb-xen maintainers add support for serial consoles.""",
 429                         hvm_paravm="""
 430 HVM machines use the virtualization features of the processor, while
 431 ParaVM machines use Xen's emulation of virtualization features.  You
 432 want an HVM virtualized machine.""",
 433                         cpu_weight="""
 434 Don't ask us!  We're as mystified as you are.""",
 435                         owner="""
 436 The owner field is used to determine <a
 437 href="help?subject=quotas">quotas</a>.  It must be the name of a
 438 locker that you are an AFS administrator of.  In particular, you or an
 439 AFS group you are a member of must have AFS rlidwka bits on the
 440 locker.  You can check see who administers the LOCKER locker using the
 441 command 'fs la /mit/LOCKER' on Athena.)  See also <a
 442 href="help?subject=administrator">administrator</a>.""",
 443                         administrator="""
 444 The administrator field determines who can access the console and
 445 power on and off the machine.  This can be either a user or a moira
 446 group.""",
 447                         quotas="""
 448 Quotas are determined on a per-locker basis.  Each quota may have a
 449 maximum of 512 megabytes of active ram, 50 gigabytes of disk, and 4
 450 active machines."""
 451                    )
 452
 453     if not subjects:
 454         subjects = sorted(help_mapping.keys())
 455
 456     d = dict(user=user,
 457              simple=simple,
 458              subjects=subjects,
 459              mapping=help_mapping)
 460
 461     return templates.help(searchList=[d])
 462
 463
 464 def badOperation(u, e):
 465     raise CodeError("Unknown operation")
 466
 467 def infoDict(user, machine):
 468     status = controls.statusInfo(machine)
 469     checkpoint.checkpoint('Getting status info')
 470     has_vnc = hasVnc(status)
 471     if status is None:
 472         main_status = dict(name=machine.name,
 473                            memory=str(machine.memory))
 474         uptime = None
 475         cputime = None
 476     else:
 477         main_status = dict(status[1:])
 478         start_time = float(main_status.get('start_time', 0))
 479         uptime = datetime.timedelta(seconds=int(time.time()-start_time))
 480         cpu_time_float = float(main_status.get('cpu_time', 0))
 481         cputime = datetime.timedelta(seconds=int(cpu_time_float))
 482     checkpoint.checkpoint('Status')
 483     display_fields = """name uptime memory state cpu_weight on_reboot
 484      on_poweroff on_crash on_xend_start on_xend_stop bootloader""".split()
 485     display_fields = [('name', 'Name'),
 486                       ('owner', 'Owner'),
 487                       ('administrator', 'Administrator'),
 488                       ('contact', 'Contact'),
 489                       ('type', 'Type'),
 490                       'NIC_INFO',
 491                       ('uptime', 'uptime'),
 492                       ('cputime', 'CPU usage'),
 493                       ('memory', 'RAM'),
 494                       'DISK_INFO',
 495                       ('state', 'state (xen format)'),
 496                       ('cpu_weight', 'CPU weight'+helppopup('cpu_weight')),
 497                       ('on_reboot', 'Action on VM reboot'),
 498                       ('on_poweroff', 'Action on VM poweroff'),
 499                       ('on_crash', 'Action on VM crash'),
 500                       ('on_xend_start', 'Action on Xen start'),
 501                       ('on_xend_stop', 'Action on Xen stop'),
 502                       ('bootloader', 'Bootloader options'),
 503                       ]
 504     fields = []
 505     machine_info = {}
 506     machine_info['name'] = machine.name
 507     machine_info['type'] = machine.type.hvm and 'HVM' or 'ParaVM'
 508     machine_info['owner'] = machine.owner
 509     machine_info['administrator'] = machine.administrator
 510     machine_info['contact'] = machine.contact
 511
 512     nic_fields = getNicInfo(machine_info, machine)
 513     nic_point = display_fields.index('NIC_INFO')
 514     display_fields = (display_fields[:nic_point] + nic_fields +
 515                       display_fields[nic_point+1:])
 516
 517     disk_fields = getDiskInfo(machine_info, machine)
 518     disk_point = display_fields.index('DISK_INFO')
 519     display_fields = (display_fields[:disk_point] + disk_fields +
 520                       display_fields[disk_point+1:])
 521
 522     main_status['memory'] += ' MiB'
 523     for field, disp in display_fields:
 524         if field in ('uptime', 'cputime') and locals()[field] is not None:
 525             fields.append((disp, locals()[field]))
 526         elif field in machine_info:
 527             fields.append((disp, machine_info[field]))
 528         elif field in main_status:
 529             fields.append((disp, main_status[field]))
 530         else:
 531             pass
 532             #fields.append((disp, None))
 533
 534     checkpoint.checkpoint('Got fields')
 535
 536
 537     max_mem = validation.maxMemory(user, machine, False)
 538     checkpoint.checkpoint('Got mem')
 539     max_disk = validation.maxDisk(user, machine)
 540     defaults = Defaults()
 541     for name in 'machine_id name administrator owner memory contact'.split():
 542         setattr(defaults, name, getattr(machine, name))
 543     defaults.disk = "%0.2f" % (machine.disks[0].size/1024.)
 544     checkpoint.checkpoint('Got defaults')
 545     d = dict(user=user,
 546              cdroms=CDROM.select(),
 547              on=status is not None,
 548              machine=machine,
 549              defaults=defaults,
 550              has_vnc=has_vnc,
 551              uptime=str(uptime),
 552              ram=machine.memory,
 553              max_mem=max_mem,
 554              max_disk=max_disk,
 555              owner_help=helppopup("owner"),
 556              fields = fields)
 557     return d
 558
 559 def info(user, fields):
 560     """Handler for info on a single VM."""
 561     machine = validation.testMachineId(user, fields.getfirst('machine_id'))
 562     d = infoDict(user, machine)
 563     checkpoint.checkpoint('Got infodict')
 564     return templates.info(searchList=[d])
 565
 566 mapping = dict(list=listVms,
 567                vnc=vnc,
 568                command=command,
 569                modify=modify,
 570                info=info,
 571                create=create,
 572                help=helpHandler)
 573
 574 def printHeaders(headers):
 575     for key, value in headers.iteritems():
 576         print '%s: %s' % (key, value)
 577     print
 578
 579
 580 def getUser():
 581     """Return the current user based on the SSL environment variables"""
 582     username = os.environ['SSL_CLIENT_S_DN_Email'].split("@")[0]
 583     return username
 584
 585 def main(operation, user, fields):
 586     start_time = time.time()
 587     fun = mapping.get(operation, badOperation)
 588
 589     if fun not in (helpHandler, ):
 590         connect('postgres://sipb-xen@sipb-xen-dev.mit.edu/sipb_xen')
 591     try:
 592         checkpoint.checkpoint('Before')
 593         output = fun(u, fields)
 594         checkpoint.checkpoint('After')
 595
 596         headers = dict(DEFAULT_HEADERS)
 597         if isinstance(output, tuple):
 598             new_headers, output = output
 599             headers.update(new_headers)
 600         e = revertStandardError()
 601         if e:
 602             output.addError(e)
 603         printHeaders(headers)
 604         output_string =  str(output)
 605         checkpoint.checkpoint('output as a string')
 606         print output_string
 607         print '<pre>%s</pre>' % checkpoint
 608     except Exception, err:
 609         if not fields.has_key('js'):
 610             if isinstance(err, CodeError):
 611                 print 'Content-Type: text/html\n'
 612                 e = revertStandardError()
 613                 print error(operation, u, fields, err, e)
 614                 sys.exit(1)
 615             if isinstance(err, InvalidInput):
 616                 print 'Content-Type: text/html\n'
 617                 e = revertStandardError()
 618                 print invalidInput(operation, u, fields, err, e)
 619                 sys.exit(1)
 620         print 'Content-Type: text/plain\n'
 621         print 'Uh-oh!  We experienced an error.'
 622         print 'Please email sipb-xen@mit.edu with the contents of this page.'
 623         print '----'
 624         e = revertStandardError()
 625         print e
 626         print '----'
 627         raise
 628
 629 if __name__ == '__main__':
 630     fields = cgi.FieldStorage()
 631     u = getUser()
 632     g.user = u
 633     operation = os.environ.get('PATH_INFO', '')
 634     if not operation:
 635         print "Status: 301 Moved Permanently"
 636         print 'Location: ' + os.environ['SCRIPT_NAME']+'/\n'
 637         sys.exit(0)
 638
 639     if operation.startswith('/'):
 640         operation = operation[1:]
 641     if not operation:
 642         operation = 'list'
 643
 644     if os.getenv("SIPB_XEN_PROFILE"):
 645         import profile
 646         profile.run('main(operation, u, fields)', 'log-'+operation)
 647     else:
 648         main(operation, u, fields)