rename overlord -> admin mode

[invirt/packages/invirt-web.git] / code / main.py

diff --git a/code/main.py b/code/main.py
index 01d6e39..42a456e 100755 (executable)
--- a/code/main.py
+++ b/code/main.py
@@ -6,6 +6,7 @@ import cPickle
 import cgi
 import datetime
 import hmac
 import cgi
 import datetime
 import hmac

+import random

 import sha
 import simplejson
 import sys
 import sha
 import simplejson
 import sys

@@ -31,16 +32,24 @@ if __name__ == '__main__':
     import atexit
     atexit.register(printError)
 
     import atexit
     atexit.register(printError)
 

-sys.path.append('/home/ecprice/.local/lib/python2.5/site-packages')
-

 import templates
 from Cheetah.Template import Template
 import templates
 from Cheetah.Template import Template

-import sipb_xen_database
-from sipb_xen_database import Machine, CDROM, ctx, connect, MachineAccess, Type, Autoinstall

 import validation
 import cache_acls
 from webcommon import InvalidInput, CodeError, State
 import controls
 import validation
 import cache_acls
 from webcommon import InvalidInput, CodeError, State
 import controls

+from getafsgroups import getAfsGroupMembers
+from invirt import database
+from invirt.database import Machine, CDROM, ctx, connect, MachineAccess, Type, Autoinstall
+from invirt.config import structs as config
+
+def pathSplit(path):
+    if path.startswith('/'):
+        path = path[1:]
+    i = path.find('/')
+    if i == -1:
+        i = len(path)
+    return path[:i], path[i:]

 
 class Checkpoint:
     def __init__(self):
 
 class Checkpoint:
     def __init__(self):

@@ -75,7 +84,8 @@ def makeErrorPre(old, addition):
     else:
         return '<p>STDERR:</p><pre>' + str(addition) + '</pre>'
 
     else:
         return '<p>STDERR:</p><pre>' + str(addition) + '</pre>'
 

-Template.sipb_xen_database = sipb_xen_database
+Template.database = database
+Template.config = config

 Template.helppopup = staticmethod(helppopup)
 Template.err = None
 
 Template.helppopup = staticmethod(helppopup)
 Template.err = None
 

@@ -103,6 +113,7 @@ class Defaults:
     cdrom = ''
     autoinstall = ''
     name = ''
     cdrom = ''
     autoinstall = ''
     name = ''

+    description = ''

     type = 'linux-hvm'
 
     def __init__(self, max_memory=None, max_disk=None, **kws):
     type = 'linux-hvm'
 
     def __init__(self, max_memory=None, max_disk=None, **kws):

@@ -117,15 +128,6 @@ class Defaults:
 
 DEFAULT_HEADERS = {'Content-Type': 'text/html'}
 
 
 DEFAULT_HEADERS = {'Content-Type': 'text/html'}
 

-def error(op, username, fields, err, emsg, traceback):
-    """Print an error page when a CodeError occurs"""
-    send_error_mail('xvm error on %s for %s: %s' % (op, username, err),
-                    'error on %s for %s: %s\n\n%s\n'
-                    % (op, username, err, emsg))
-    d = dict(op=op, user=username, fields=fields,
-             errorMessage=str(err), stderr=emsg, traceback=traceback)
-    return templates.error(searchList=[d])
-

 def invalidInput(op, username, fields, err, emsg):
     """Print an error page when an InvalidInput exception occurs"""
     d = dict(op=op, user=username, err_field=err.err_field,
 def invalidInput(op, username, fields, err, emsg):
     """Print an error page when an InvalidInput exception occurs"""
     d = dict(op=op, user=username, err_field=err.err_field,

@@ -144,14 +146,14 @@ def hasVnc(status):
     return False
 
 def parseCreate(username, state, fields):
     return False
 
 def parseCreate(username, state, fields):

-    kws = dict([(kw, fields.getfirst(kw)) for kw in 'name owner memory disksize vmtype cdrom clone_from'.split()])
+    kws = dict([(kw, fields.getfirst(kw)) for kw in 'name description owner memory disksize vmtype cdrom autoinstall'.split()])

     validate = validation.Validate(username, state, strict=True, **kws)
     validate = validation.Validate(username, state, strict=True, **kws)

-    return dict(contact=username, name=validate.name, memory=validate.memory,
+    return dict(contact=username, name=validate.name, description=validate.description, memory=validate.memory,

                 disksize=validate.disksize, owner=validate.owner, machine_type=validate.vmtype,
                 cdrom=getattr(validate, 'cdrom', None),
                 disksize=validate.disksize, owner=validate.owner, machine_type=validate.vmtype,
                 cdrom=getattr(validate, 'cdrom', None),

-                clone_from=getattr(validate, 'clone_from', None))
+                autoinstall=getattr(validate, 'autoinstall', None))

 
 

-def create(username, state, fields):
+def create(username, state, path, fields):

     """Handler for create requests."""
     try:
         parsed_fields = parseCreate(username, state, fields)
     """Handler for create requests."""
     try:
         parsed_fields = parseCreate(username, state, fields)

@@ -214,14 +216,14 @@ def getListDict(username, state):
              can_clone=can_clone)
     return d
 
              can_clone=can_clone)
     return d
 

-def listVms(username, state, fields):
+def listVms(username, state, path, fields):

     """Handler for list requests."""
     checkpoint.checkpoint('Getting list dict')
     d = getListDict(username, state)
     checkpoint.checkpoint('Got list dict')
     return templates.list(searchList=[d])
 
     """Handler for list requests."""
     checkpoint.checkpoint('Getting list dict')
     d = getListDict(username, state)
     checkpoint.checkpoint('Got list dict')
     return templates.list(searchList=[d])
 

-def vnc(username, state, fields):
+def vnc(username, state, path, fields):

     """VNC applet page.
 
     Note that due to same-domain restrictions, the applet connects to
     """VNC applet page.
 
     Note that due to same-domain restrictions, the applet connects to

@@ -255,6 +257,11 @@ def vnc(username, state, fields):
     token = {'data': pickled_data, 'digest': m.digest()}
     token = cPickle.dumps(token)
     token = base64.urlsafe_b64encode(token)
     token = {'data': pickled_data, 'digest': m.digest()}
     token = cPickle.dumps(token)
     token = base64.urlsafe_b64encode(token)

+    host = controls.listHost(machine)
+    if host:
+        port = 10003 + [h.hostname for h in config.hosts].index(host)
+    else:
+        port = 5900 # dummy

 
     status = controls.statusInfo(machine)
     has_vnc = hasVnc(status)
 
     status = controls.statusInfo(machine)
     has_vnc = hasVnc(status)

@@ -264,6 +271,7 @@ def vnc(username, state, fields):
              has_vnc=has_vnc,
              machine=machine,
              hostname=state.environ.get('SERVER_NAME', 'localhost'),
              has_vnc=has_vnc,
              machine=machine,
              hostname=state.environ.get('SERVER_NAME', 'localhost'),

+             port=port,

              authtoken=token)
     return templates.vnc(searchList=[d])
 
              authtoken=token)
     return templates.vnc(searchList=[d])
 

@@ -275,7 +283,7 @@ def getHostname(nic):
     if nic.hostname and '.' in nic.hostname:
         return nic.hostname
     elif nic.machine:
     if nic.hostname and '.' in nic.hostname:
         return nic.hostname
     elif nic.machine:

-        return nic.machine.name + '.xvm.mit.edu'
+        return nic.machine.name + '.' + config.dns.domains[0]

     else:
         return None
 
     else:
         return None
 

@@ -318,7 +326,7 @@ def getDiskInfo(data_dict, machine):
         data_dict['%s_size' % name] = "%0.1f GiB" % (disk.size / 1024.)
     return disk_fields
 
         data_dict['%s_size' % name] = "%0.1f GiB" % (disk.size / 1024.)
     return disk_fields
 

-def command(username, state, fields):
+def command(username, state, path, fields):

     """Handler for running commands like boot and delete on a VM."""
     back = fields.getfirst('back')
     try:
     """Handler for running commands like boot and delete on a VM."""
     back = fields.getfirst('back')
     try:

@@ -342,7 +350,7 @@ def command(username, state, fields):
     elif back == 'info':
         machine = validation.Validate(username, state, machine_id=fields.getfirst('machine_id')).machine
         return ({'Status': '303 See Other',
     elif back == 'info':
         machine = validation.Validate(username, state, machine_id=fields.getfirst('machine_id')).machine
         return ({'Status': '303 See Other',

-                 'Location': '/info?machine_id=%d' % machine.machine_id},
+                 'Location': 'info?machine_id=%d' % machine.machine_id},

                 "You shouldn't see this message.")
     else:
         raise InvalidInput('back', back, 'Not a known back page.')
                 "You shouldn't see this message.")
     else:
         raise InvalidInput('back', back, 'Not a known back page.')

@@ -355,7 +363,7 @@ def modifyDict(username, state, fields):
     olddisk = {}
     transaction = ctx.current.create_transaction()
     try:
     olddisk = {}
     transaction = ctx.current.create_transaction()
     try:

-        kws = dict([(kw, fields.getfirst(kw)) for kw in 'machine_id owner admin contact name memory vmtype disksize'.split()])
+        kws = dict([(kw, fields.getfirst(kw)) for kw in 'machine_id owner admin contact name description memory vmtype disksize'.split()])

         validate = validation.Validate(username, state, **kws)
         machine = validate.machine
         oldname = machine.name
         validate = validation.Validate(username, state, **kws)
         machine = validate.machine
         oldname = machine.name

@@ -380,6 +388,8 @@ def modifyDict(username, state, fields):
             update_acl = True
         if hasattr(validate, 'name'):
             machine.name = validate.name
             update_acl = True
         if hasattr(validate, 'name'):
             machine.name = validate.name

+        if hasattr(validate, 'description'):
+            machine.description = validate.description

         if hasattr(validate, 'admin') and validate.admin != machine.administrator:
             machine.administrator = validate.admin
             update_acl = True
         if hasattr(validate, 'admin') and validate.admin != machine.administrator:
             machine.administrator = validate.admin
             update_acl = True

@@ -402,7 +412,7 @@ def modifyDict(username, state, fields):
                 command="modify",
                 machine=machine)
 
                 command="modify",
                 machine=machine)
 

-def modify(username, state, fields):
+def modify(username, state, path, fields):

     """Handler for modifying attributes of a machine."""
     try:
         modify_dict = modifyDict(username, state, fields)
     """Handler for modifying attributes of a machine."""
     try:
         modify_dict = modifyDict(username, state, fields)

@@ -422,7 +432,7 @@ def modify(username, state, fields):
     return templates.info(searchList=[info_dict])
 
 
     return templates.info(searchList=[info_dict])
 
 

-def helpHandler(username, state, fields):
+def helpHandler(username, state, path, fields):

     """Handler for help messages."""
     simple = fields.getfirst('simple')
     subjects = fields.getlist('subject')
     """Handler for help messages."""
     simple = fields.getfirst('simple')
     subjects = fields.getlist('subject')

@@ -430,8 +440,8 @@ def helpHandler(username, state, fields):
     help_mapping = {'ParaVM Console': """
 ParaVM machines do not support local console access over VNC.  To
 access the serial console of these machines, you can SSH with Kerberos
     help_mapping = {'ParaVM Console': """
 ParaVM machines do not support local console access over VNC.  To
 access the serial console of these machines, you can SSH with Kerberos

-to console.xvm.mit.edu, using the name of the machine as your
-username.""",
+to console.%s, using the name of the machine as your
+username.""" % config.dns.domains[0],

                     'HVM/ParaVM': """
 HVM machines use the virtualization features of the processor, while
 ParaVM machines use Xen's emulation of virtualization features.  You
                     'HVM/ParaVM': """
 HVM machines use the virtualization features of the processor, while
 ParaVM machines use Xen's emulation of virtualization features.  You

@@ -473,9 +483,9 @@ console will suffer artifacts.
     return templates.help(searchList=[d])
 
 
     return templates.help(searchList=[d])
 
 

-def badOperation(u, s, e):
+def badOperation(u, s, p, e):

     """Function called when accessing an unknown URI."""
     """Function called when accessing an unknown URI."""

-    raise CodeError("Unknown operation")
+    return ({'Status': '404 Not Found'}, 'Invalid operation.')

 
 def infoDict(username, state, machine):
     """Get the variables used by info.tmpl."""
 
 def infoDict(username, state, machine):
     """Get the variables used by info.tmpl."""

@@ -489,6 +499,7 @@ def infoDict(username, state, machine):
         cputime = None
     else:
         main_status = dict(status[1:])
         cputime = None
     else:
         main_status = dict(status[1:])

+        main_status['host'] = controls.listHost(machine)

         start_time = float(main_status.get('start_time', 0))
         uptime = datetime.timedelta(seconds=int(time.time()-start_time))
         cpu_time_float = float(main_status.get('cpu_time', 0))
         start_time = float(main_status.get('start_time', 0))
         uptime = datetime.timedelta(seconds=int(time.time()-start_time))
         cpu_time_float = float(main_status.get('cpu_time', 0))

@@ -497,6 +508,7 @@ def infoDict(username, state, machine):
     display_fields = """name uptime memory state cpu_weight on_reboot 
      on_poweroff on_crash on_xend_start on_xend_stop bootloader""".split()
     display_fields = [('name', 'Name'),
     display_fields = """name uptime memory state cpu_weight on_reboot 
      on_poweroff on_crash on_xend_start on_xend_stop bootloader""".split()
     display_fields = [('name', 'Name'),

+                      ('description', 'Description'),

                       ('owner', 'Owner'),
                       ('administrator', 'Administrator'),
                       ('contact', 'Contact'),
                       ('owner', 'Owner'),
                       ('administrator', 'Administrator'),
                       ('contact', 'Contact'),

@@ -504,6 +516,7 @@ def infoDict(username, state, machine):
                       'NIC_INFO',
                       ('uptime', 'uptime'),
                       ('cputime', 'CPU usage'),
                       'NIC_INFO',
                       ('uptime', 'uptime'),
                       ('cputime', 'CPU usage'),

+                      ('host', 'Hosted on'),

                       ('memory', 'RAM'),
                       'DISK_INFO',
                       ('state', 'state (xen format)'),
                       ('memory', 'RAM'),
                       'DISK_INFO',
                       ('state', 'state (xen format)'),

@@ -518,6 +531,7 @@ def infoDict(username, state, machine):
     fields = []
     machine_info = {}
     machine_info['name'] = machine.name
     fields = []
     machine_info = {}
     machine_info['name'] = machine.name

+    machine_info['description'] = machine.description

     machine_info['type'] = machine.type.hvm and 'HVM' or 'ParaVM'
     machine_info['owner'] = machine.owner
     machine_info['administrator'] = machine.administrator
     machine_info['type'] = machine.type.hvm and 'HVM' or 'ParaVM'
     machine_info['owner'] = machine.owner
     machine_info['administrator'] = machine.administrator

@@ -552,7 +566,7 @@ def infoDict(username, state, machine):
     checkpoint.checkpoint('Got mem')
     max_disk = validation.maxDisk(machine.owner, machine)
     defaults = Defaults()
     checkpoint.checkpoint('Got mem')
     max_disk = validation.maxDisk(machine.owner, machine)
     defaults = Defaults()

-    for name in 'machine_id name administrator owner memory contact'.split():
+    for name in 'machine_id name description administrator owner memory contact'.split():

         setattr(defaults, name, getattr(machine, name))
     defaults.type = machine.type.type_id
     defaults.disk = "%0.2f" % (machine.disks[0].size/1024.)
         setattr(defaults, name, getattr(machine, name))
     defaults.type = machine.type.type_id
     defaults.disk = "%0.2f" % (machine.disks[0].size/1024.)

@@ -570,20 +584,32 @@ def infoDict(username, state, machine):
              fields = fields)
     return d
 
              fields = fields)
     return d
 

-def info(username, state, fields):
+def info(username, state, path, fields):

     """Handler for info on a single VM."""
     machine = validation.Validate(username, state, machine_id=fields.getfirst('machine_id')).machine
     d = infoDict(username, state, machine)
     checkpoint.checkpoint('Got infodict')
     return templates.info(searchList=[d])
 
     """Handler for info on a single VM."""
     machine = validation.Validate(username, state, machine_id=fields.getfirst('machine_id')).machine
     d = infoDict(username, state, machine)
     checkpoint.checkpoint('Got infodict')
     return templates.info(searchList=[d])
 

-def unauthFront(_, _2, fields):
+def unauthFront(_, _2, _3, fields):

     """Information for unauth'd users."""
     return templates.unauth(searchList=[{'simple' : True}])
 
     """Information for unauth'd users."""
     return templates.unauth(searchList=[{'simple' : True}])
 

-def throwError(_, __, ___):
+def admin(username, state, path, fields):
+    if path == '':
+        return ({'Status': '303 See Other',
+                 'Location': 'admin/'},
+                "You shouldn't see this message.")
+    if not username in getAfsGroupMembers('system:xvm', 'athena.mit.edu'):
+        raise InvalidInput('username', username,
+                           'Not in admin group %s.' % 'system:xvm')
+    newstate = State(username, isadmin=True)
+    newstate.environ = state.environ
+    return handler(username, newstate, path, fields)
+
+def throwError(_, __, ___, ____):

     """Throw an error, to test the error-tracing mechanisms."""
     """Throw an error, to test the error-tracing mechanisms."""

-    raise CodeError("test of the emergency broadcast system")
+    raise RuntimeError("test of the emergency broadcast system")

 
 mapping = dict(list=listVms,
                vnc=vnc,
 
 mapping = dict(list=listVms,
                vnc=vnc,

@@ -593,6 +619,7 @@ mapping = dict(list=listVms,
                create=create,
                help=helpHandler,
                unauth=unauthFront,
                create=create,
                help=helpHandler,
                unauth=unauthFront,

+               admin=admin,

                errortest=throwError)
 
 def printHeaders(headers):
                errortest=throwError)
 
 def printHeaders(headers):

@@ -604,26 +631,40 @@ def printHeaders(headers):
 def send_error_mail(subject, body):
     import subprocess
 
 def send_error_mail(subject, body):
     import subprocess
 

-    to = 'xvm@mit.edu'
+    to = config.web.errormail

     mail = """To: %s
     mail = """To: %s

-From: root@xvm.mit.edu
+From: root@%s

 Subject: %s
 
 %s
 Subject: %s
 
 %s

-""" % (to, subject, body)
+""" % (to, config.web.hostname, subject, body)

     p = subprocess.Popen(['/usr/sbin/sendmail', to], stdin=subprocess.PIPE)
     p.stdin.write(mail)
     p.stdin.close()
     p.wait()
 
     p = subprocess.Popen(['/usr/sbin/sendmail', to], stdin=subprocess.PIPE)
     p.stdin.write(mail)
     p.stdin.close()
     p.wait()
 

+def show_error(op, username, fields, err, emsg, traceback):
+    """Print an error page when an exception occurs"""
+    d = dict(op=op, user=username, fields=fields,
+             errorMessage=str(err), stderr=emsg, traceback=traceback)
+    details = templates.error_raw(searchList=[d])
+    if username not in ('price', 'ecprice', 'andersk'): #add yourself at will
+        send_error_mail('xvm error on %s for %s: %s' % (op, username, err),
+                        details)
+    d['details'] = details
+    return templates.error(searchList=[d])
+

 def getUser(environ):
     """Return the current user based on the SSL environment variables"""
 def getUser(environ):
     """Return the current user based on the SSL environment variables"""

-    email = environ.get('SSL_CLIENT_S_DN_Email', None)
-    if email is None:
-        return None
-    if not email.endswith('@MIT.EDU'):
-        return None
-    return email[:-8]
+    return environ.get('REMOTE_USER', None)
+
+def handler(username, state, path, fields):
+    operation, path = pathSplit(path)
+    if not operation:
+        operation = 'list'
+    print 'Starting', operation
+    fun = mapping.get(operation, badOperation)
+    return fun(username, state, path, fields)

 
 class App:
     def __init__(self, environ, start_response):
 
 class App:
     def __init__(self, environ, start_response):

@@ -634,76 +675,55 @@ class App:
         self.state = State(self.username)
         self.state.environ = environ
 
         self.state = State(self.username)
         self.state.environ = environ
 

+        random.seed() #sigh
+

     def __iter__(self):
     def __iter__(self):

+        start_time = time.time()
+        database.clear_cache()

         sys.stderr = StringIO()
         fields = cgi.FieldStorage(fp=self.environ['wsgi.input'], environ=self.environ)
         operation = self.environ.get('PATH_INFO', '')
         if not operation:
         sys.stderr = StringIO()
         fields = cgi.FieldStorage(fp=self.environ['wsgi.input'], environ=self.environ)
         operation = self.environ.get('PATH_INFO', '')
         if not operation:

-            self.start("301 Moved Permanently", [('Location',
-                                                  self.environ['SCRIPT_NAME']+'/')])
+            self.start("301 Moved Permanently", [('Location', './')])

             return
         if self.username is None:
             operation = 'unauth'
             return
         if self.username is None:
             operation = 'unauth'

-        if operation.startswith('/'):
-            operation = operation[1:]
-        if not operation:
-            operation = 'list'
-        print 'Starting', operation

 
 

-        start_time = time.time()
-        fun = mapping.get(operation, badOperation)

         try:
             checkpoint.checkpoint('Before')
         try:
             checkpoint.checkpoint('Before')

-            output = fun(self.username, self.state, fields)
+            output = handler(self.username, self.state, operation, fields)

             checkpoint.checkpoint('After')
 
             headers = dict(DEFAULT_HEADERS)
             if isinstance(output, tuple):
                 new_headers, output = output
                 headers.update(new_headers)
             checkpoint.checkpoint('After')
 
             headers = dict(DEFAULT_HEADERS)
             if isinstance(output, tuple):
                 new_headers, output = output
                 headers.update(new_headers)

-            print 'MOO2'

             e = revertStandardError()
             if e:
             e = revertStandardError()
             if e:

-                if isinstance(output, basestring):
-                    sys.stderr = StringIO()
-                    x = str(output)
-                    print >> sys.stderr, x
-                    print >> sys.stderr, 'XXX'
-                    print >> sys.stderr, e
-                    raise Exception()
-                output.addError(e)
+                if hasattr(output, 'addError'):
+                    output.addError(e)
+                else:
+                    # This only happens on redirects, so it'd be a pain to get
+                    # the message to the user.  Maybe in the response is useful.
+                    output = output + '\n\nstderr:\n' + e

             output_string =  str(output)
             checkpoint.checkpoint('output as a string')
         except Exception, err:
             output_string =  str(output)
             checkpoint.checkpoint('output as a string')
         except Exception, err:

-            import traceback

             if not fields.has_key('js'):
             if not fields.has_key('js'):

-                if isinstance(err, CodeError):
-                    self.start('500 Internal Server Error', [('Content-Type', 'text/html')])
-                    e = revertStandardError()
-                    s = error(operation, self.username, fields,
-                              err, e, traceback.format_exc())
-                    yield str(s)
-                    return

                 if isinstance(err, InvalidInput):
                     self.start('200 OK', [('Content-Type', 'text/html')])
                     e = revertStandardError()
                 if isinstance(err, InvalidInput):
                     self.start('200 OK', [('Content-Type', 'text/html')])
                     e = revertStandardError()

-                    yield str(invalidInput(operation, self.username, fields, err, e))
+                    yield str(invalidInput(operation, self.username, fields,
+                                           err, e))

                     return
                     return

-            self.start('500 Internal Server Error', [('Content-Type', 'text/plain')])
-            send_error_mail('xvm error: %s' % (err,),
-                            '%s\n' % (traceback.format_exc(),))
-            yield '''Uh-oh!  We experienced an error.
-Sorry about that.  We've gotten mail about it.
-
-Feel free to poke us at xvm@mit.edu if this bug is
-consistently biting you and we don't seem to be fixing it.
-
-In case you're curious, the gory details are here.
-----
-%s
-----
-%s
-----''' % (str(err), traceback.format_exc())
+            import traceback
+            self.start('500 Internal Server Error',
+                       [('Content-Type', 'text/html')])
+            e = revertStandardError()
+            s = show_error(operation, self.username, fields,
+                           err, e, traceback.format_exc())
+            yield str(s)
+            return

         status = headers.setdefault('Status', '200 OK')
         del headers['Status']
         self.start(status, headers.items())
         status = headers.setdefault('Status', '200 OK')
         del headers['Status']
         self.start(status, headers.items())

@@ -712,7 +732,7 @@ In case you're curious, the gory details are here.
             yield '<pre>%s</pre>' % cgi.escape(str(checkpoint))
 
 def constructor():
             yield '<pre>%s</pre>' % cgi.escape(str(checkpoint))
 
 def constructor():

-    connect('postgres://sipb-xen@sipb-xen-dev.mit.edu/sipb_xen')
+    connect()

     return App
 
 def main():
     return App
 
 def main():