"""Move stderr to stdout, and return the contents of the old stderr."""
errio = sys.stderr
if not isinstance(errio, StringIO):
- return None
+ return ''
sys.stderr = sys.stdout
errio.seek(0)
return errio.read()
if __name__ == '__main__':
import atexit
atexit.register(printError)
- sys.stderr = StringIO()
-
-sys.path.append('/home/ecprice/.local/lib/python2.5/site-packages')
import templates
from Cheetah.Template import Template
cdrom = ''
autoinstall = ''
name = ''
+ description = ''
type = 'linux-hvm'
def __init__(self, max_memory=None, max_disk=None, **kws):
DEFAULT_HEADERS = {'Content-Type': 'text/html'}
-def error(op, username, fields, err, emsg):
- """Print an error page when a CodeError occurs"""
- d = dict(op=op, user=username, errorMessage=str(err),
- stderr=emsg)
- 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,
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)
- 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),
- clone_from=getattr(validate, 'clone_from', None))
+ autoinstall=getattr(validate, 'autoinstall', None))
def create(username, state, fields):
"""Handler for create requests."""
return templates.list(searchList=[d])
elif back == 'info':
machine = validation.Validate(username, state, machine_id=fields.getfirst('machine_id')).machine
- return ({'Status': '302',
+ return ({'Status': '303 See Other',
'Location': '/info?machine_id=%d' % machine.machine_id},
"You shouldn't see this message.")
else:
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
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
def badOperation(u, s, e):
"""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."""
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'),
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
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.)
"""Information for unauth'd users."""
return templates.unauth(searchList=[{'simple' : True}])
+def throwError(_, __, ___):
+ """Throw an error, to test the error-tracing mechanisms."""
+ raise RuntimeError("test of the emergency broadcast system")
+
mapping = dict(list=listVms,
vnc=vnc,
command=command,
info=info,
create=create,
help=helpHandler,
- unauth=unauthFront)
+ unauth=unauthFront,
+ errortest=throwError)
def printHeaders(headers):
"""Print a dictionary as HTTP headers."""
print '%s: %s' % (key, value)
print
+def send_error_mail(subject, body):
+ import subprocess
+
+ to = 'xvm@mit.edu'
+ mail = """To: %s
+From: root@xvm.mit.edu
+Subject: %s
+
+%s
+""" % (to, subject, body)
+ 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"""
- 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)
class App:
def __init__(self, environ, start_response):
self.state.environ = environ
def __iter__(self):
+ sipb_xen_database.clear_cache()
+ sys.stderr = StringIO()
fields = cgi.FieldStorage(fp=self.environ['wsgi.input'], environ=self.environ)
- print >> sys.stderr, fields
operation = self.environ.get('PATH_INFO', '')
if not operation:
self.start("301 Moved Permanently", [('Location',
if isinstance(output, tuple):
new_headers, output = output
headers.update(new_headers)
- print 'MOO2'
e = revertStandardError()
if e:
if isinstance(output, basestring):
checkpoint.checkpoint('output as a string')
except Exception, err:
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)
- yield str(s)
- return
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
- self.start('500 Internal Server Error', [('Content-Type', 'text/plain')])
import traceback
- yield '''Uh-oh! We experienced an error.'
-Please email xvm-dev@mit.edu with the contents of this page.'
-----
-%s
-----
-%s
-----''' % (str(err), traceback.format_exc())
+ 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())
projects / invirt/packages/invirt-web.git / blobdiff