Documentation + cleaning up a little.
[invirt/packages/invirt-web.git] / templates / main.py
1 #!/usr/bin/python
2
3 import sys
4 import cgi
5 import os
6 import string
7 import subprocess
8 import re
9 import time
10 import cPickle
11 import base64
12 import sha
13 import hmac
14 import datetime
15
16 sys.stderr = sys.stdout
17 sys.path.append('/home/ecprice/.local/lib/python2.5/site-packages')
18
19 from Cheetah.Template import Template
20 from sipb_xen_database import *
21 import random
22
23 class MyException(Exception):
24     """Base class for my exceptions"""
25     pass
26
27 class InvalidInput(MyException):
28     """Exception for user-provided input is invalid but maybe in good faith.
29
30     This would include setting memory to negative (which might be a
31     typo) but not setting an invalid boot CD (which requires bypassing
32     the select box).
33     """
34     pass
35
36 class CodeError(MyException):
37     """Exception for internal errors or bad faith input."""
38     pass
39
40
41
42 def helppopup(subj):
43     """Return HTML code for a (?) link to a specified help topic"""
44     return '<span class="helplink"><a href="help?subject='+subj+'&amp;simple=true" target="_blank" onclick="return helppopup(\''+subj+'\')">(?)</a></span>'
45
46
47 global_dict = {}
48 global_dict['helppopup'] = helppopup
49
50
51 # ... and stolen from xend/uuid.py
52 def randomUUID():
53     """Generate a random UUID."""
54
55     return [ random.randint(0, 255) for _ in range(0, 16) ]
56
57 def uuidToString(u):
58     """Turn a numeric UUID to a hyphen-seperated one."""
59     return "-".join(["%02x" * 4, "%02x" * 2, "%02x" * 2, "%02x" * 2,
60                      "%02x" * 6]) % tuple(u)
61
62 MAX_MEMORY_TOTAL = 512
63 MAX_MEMORY_SINGLE = 256
64 MIN_MEMORY_SINGLE = 16
65 MAX_DISK_TOTAL = 50
66 MAX_DISK_SINGLE = 50
67 MIN_DISK_SINGLE = 0.1
68 MAX_VMS_TOTAL = 10
69 MAX_VMS_ACTIVE = 4
70
71 def getMachinesByOwner(owner):
72     """Return the machines owned by a given owner."""
73     return Machine.select_by(owner=owner)
74
75 def maxMemory(user, machine=None, on=None):
76     """Return the maximum memory for a machine or a user.
77
78     If machine is None, return the memory available for a new 
79     machine.  Else, return the maximum that machine can have.
80
81     on is a dictionary from machines to booleans, whether a machine is
82     on.  If None, it is recomputed. XXX make this global?
83     """
84
85     machines = getMachinesByOwner(user.username)
86     if on is None:
87         on = getUptimes(machines)
88     active_machines = [x for x in machines if on[x]]
89     mem_usage = sum([x.memory for x in active_machines if x != machine])
90     return min(MAX_MEMORY_SINGLE, MAX_MEMORY_TOTAL-mem_usage)
91
92 def maxDisk(user, machine=None):
93     machines = getMachinesByOwner(user.username)
94     disk_usage = sum([sum([y.size for y in x.disks])
95                       for x in machines if x != machine])
96     return min(MAX_DISK_SINGLE, MAX_DISK_TOTAL-disk_usage/1024.)
97
98 def canAddVm(user, on=None):
99     machines = getMachinesByOwner(user.username)
100     if on is None:
101         on = getUptimes(machines)
102     active_machines = [x for x in machines if on[x]]
103     return (len(machines) < MAX_VMS_TOTAL and
104             len(active_machines) < MAX_VMS_ACTIVE)
105
106 def haveAccess(user, machine):
107     """Return whether a user has access to a machine"""
108     if user.username == 'moo':
109         return True
110     return machine.owner == user.username
111
112 def error(op, user, fields, err):
113     """Print an error page when a CodeError occurs"""
114     d = dict(op=op, user=user, errorMessage=str(err))
115     print Template(file='error.tmpl', searchList=[d, global_dict]);
116
117 def validMachineName(name):
118     """Check that name is valid for a machine name"""
119     if not name:
120         return False
121     charset = string.ascii_letters + string.digits + '-_'
122     if name[0] in '-_' or len(name) > 22:
123         return False
124     for x in name:
125         if x not in charset:
126             return False
127     return True
128
129 def kinit(username = 'tabbott/extra', keytab = '/etc/tabbott.keytab'):
130     """Kinit with a given username and keytab"""
131
132     p = subprocess.Popen(['kinit', "-k", "-t", keytab, username],
133                          stderr=subprocess.PIPE)
134     e = p.wait()
135     if e:
136         raise CodeError("Error %s in kinit: %s" % (e, p.stderr.read()))
137
138 def checkKinit():
139     """If we lack tickets, kinit."""
140     p = subprocess.Popen(['klist', '-s'])
141     if p.wait():
142         kinit()
143
144 def remctl(*args, **kws):
145     """Perform a remctl and return the output.
146
147     kinits if necessary, and outputs errors to stderr.
148     """
149     checkKinit()
150     p = subprocess.Popen(['remctl', 'black-mesa.mit.edu']
151                          + list(args),
152                          stdout=subprocess.PIPE,
153                          stderr=subprocess.PIPE)
154     if kws.get('err'):
155         p.wait()
156         return p.stdout.read(), p.stderr.read()
157     if p.wait():
158         raise CodeError('ERROR on remctl %s: %s' %
159                           (args, p.stderr.read()))
160     return p.stdout.read()
161
162 def makeDisks():
163     """Update the lvm partitions to include all disks in the database."""
164     remctl('web', 'lvcreate')
165
166 def bootMachine(machine, cdtype):
167     """Boot a machine with a given boot CD.
168
169     If cdtype is None, give no boot cd.  Otherwise, it is the string
170     id of the CD (e.g. 'gutsy_i386')
171     """
172     if cdtype is not None:
173         remctl('web', 'vmboot', machine.name,
174                cdtype)
175     else:
176         remctl('web', 'vmboot', machine.name)
177
178 def registerMachine(machine):
179     """Register a machine to be controlled by the web interface"""
180     remctl('web', 'register', machine.name)
181
182 def unregisterMachine(machine):
183     """Unregister a machine to not be controlled by the web interface"""
184     remctl('web', 'unregister', machine.name)
185
186 def parseStatus(s):
187     """Parse a status string into nested tuples of strings.
188
189     s = output of xm list --long <machine_name>
190     """
191     values = re.split('([()])', s)
192     stack = [[]]
193     for v in values[2:-2]: #remove initial and final '()'
194         if not v:
195             continue
196         v = v.strip()
197         if v == '(':
198             stack.append([])
199         elif v == ')':
200             if len(stack[-1]) == 1:
201                 stack[-1].append('')
202             stack[-2].append(stack[-1])
203             stack.pop()
204         else:
205             if not v:
206                 continue
207             stack[-1].extend(v.split())
208     return stack[-1]
209
210 def getUptimes(machines):
211     """Return a dictionary mapping machine names to uptime strings"""
212     value_string = remctl('web', 'listvms')
213     lines = value_string.splitlines()
214     d = {}
215     for line in lines[1:]:
216         lst = line.split()
217         name, id = lst[:2]
218         uptime = ' '.join(lst[2:])
219         d[name] = uptime
220     ans = {}
221     for m in machines:
222         ans[m] = d.get(m.name)
223     return ans
224
225 def statusInfo(machine):
226     """Return the status list for a given machine.
227
228     Gets and parses xm list --long
229     """
230     value_string, err_string = remctl('list-long', machine.name, err=True)
231     if 'Unknown command' in err_string:
232         raise CodeError("ERROR in remctl list-long %s is not registered" % (machine.name,))
233     elif 'does not exist' in err_string:
234         return None
235     elif err_string:
236         raise CodeError("ERROR in remctl list-long %s:  %s" % (machine.name, err_string))
237     status = parseStatus(value_string)
238     return status
239
240 def hasVnc(status):
241     """Does the machine with a given status list support VNC?"""
242     if status is None:
243         return False
244     for l in status:
245         if l[0] == 'device' and l[1][0] == 'vfb':
246             d = dict(l[1][1:])
247             return 'location' in d
248     return False
249
250 def createVm(user, name, memory, disk, is_hvm, cdrom):
251     """Create a VM and put it in the database"""
252     # put stuff in the table
253     transaction = ctx.current.create_transaction()
254     try:
255         if memory > maxMemory(user):
256             raise InvalidInput("Too much memory requested")
257         if disk > maxDisk(user) * 1024:
258             raise InvalidInput("Too much disk requested")
259         if not canAddVm(user):
260             raise InvalidInput("Too many VMs requested")
261         res = meta.engine.execute('select nextval(\'"machines_machine_id_seq"\')')
262         id = res.fetchone()[0]
263         machine = Machine()
264         machine.machine_id = id
265         machine.name = name
266         machine.memory = memory
267         machine.owner = user.username
268         machine.contact = user.email
269         machine.uuid = uuidToString(randomUUID())
270         machine.boot_off_cd = True
271         machine_type = Type.get_by(hvm=is_hvm)
272         machine.type_id = machine_type.type_id
273         ctx.current.save(machine)
274         disk = Disk(machine.machine_id, 
275                     'hda', disk)
276         open = NIC.select_by(machine_id=None)
277         if not open: #No IPs left!
278             raise CodeError("No IP addresses left!  Contact sipb-xen-dev@mit.edu")
279         nic = open[0]
280         nic.machine_id = machine.machine_id
281         nic.hostname = name
282         ctx.current.save(nic)    
283         ctx.current.save(disk)
284         transaction.commit()
285     except:
286         transaction.rollback()
287         raise
288     registerMachine(machine)
289     makeDisks()
290     # tell it to boot with cdrom
291     bootMachine(machine, cdrom)
292
293     return machine
294
295 def validMemory(user, memory, machine=None):
296     """Parse and validate limits for memory for a given user and machine."""
297     try:
298         memory = int(memory)
299         if memory < MIN_MEMORY_SINGLE:
300             raise ValueError
301     except ValueError:
302         raise InvalidInput("Invalid memory amount; must be at least %s MB" %
303                           MIN_MEMORY_SINGLE)
304     if memory > maxMemory(user, machine):
305         raise InvalidInput("Too much memory requested")
306     return memory
307
308 def validDisk(user, disk, machine=None):
309     """Parse and validate limits for disk for a given user and machine."""
310     try:
311         disk = float(disk)
312         if disk > maxDisk(user, machine):
313             raise InvalidInput("Too much disk requested")
314         disk = int(disk * 1024)
315         if disk < MIN_DISK_SINGLE * 1024:
316             raise ValueError
317     except ValueError:
318         raise InvalidInput("Invalid disk amount; minimum is %s GB" %
319                           MIN_DISK_SINGLE)
320     return disk
321
322 def create(user, fields):
323     """Handler for create requests."""
324     name = fields.getfirst('name')
325     if not validMachineName(name):
326         raise InvalidInput("Invalid name '%s'" % name)
327     name = user.username + '_' + name.lower()
328
329     if Machine.get_by(name=name):
330         raise InvalidInput("A machine named '%s' already exists" % name)
331     
332     memory = fields.getfirst('memory')
333     memory = validMemory(user, memory)
334     
335     disk = fields.getfirst('disk')
336     disk = validDisk(user, disk)
337
338     vm_type = fields.getfirst('vmtype')
339     if vm_type not in ('hvm', 'paravm'):
340         raise CodeError("Invalid vm type '%s'"  % vm_type)    
341     is_hvm = (vm_type == 'hvm')
342
343     cdrom = fields.getfirst('cdrom')
344     if cdrom is not None and not CDROM.get(cdrom):
345         raise CodeError("Invalid cdrom type '%s'" % cdrom)    
346     
347     machine = createVm(user, name, memory, disk, is_hvm, cdrom)
348     d = dict(user=user,
349              machine=machine)
350     print Template(file='create.tmpl',
351                    searchList=[d, global_dict]);
352
353 def listVms(user, fields):
354     """Handler for list requests."""
355     machines = [m for m in Machine.select() if haveAccess(user, m)]    
356     on = {}
357     has_vnc = {}
358     uptimes = getUptimes(machines)
359     on = uptimes
360     for m in machines:
361         if not on[m]:
362             has_vnc[m] = 'Off'
363         elif m.type.hvm:
364             has_vnc[m] = True
365         else:
366             has_vnc[m] = "ParaVM"+helppopup("paravm_console")
367     #     for m in machines:
368     #         status = statusInfo(m)
369     #         on[m.name] = status is not None
370     #         has_vnc[m.name] = hasVnc(status)
371     max_mem=maxMemory(user, on=on)
372     max_disk=maxDisk(user)
373     d = dict(user=user,
374              can_add_vm=canAddVm(user, on=on),
375              max_mem=max_mem,
376              max_disk=max_disk,
377              default_mem=max_mem,
378              default_disk=min(4.0, max_disk),
379              machines=machines,
380              has_vnc=has_vnc,
381              uptimes=uptimes,
382              cdroms=CDROM.select())
383     print Template(file='list.tmpl', searchList=[d, global_dict])
384
385 def testMachineId(user, machineId, exists=True):
386     """Parse, validate and check authorization for a given machineId.
387
388     If exists is False, don't check that it exists.
389     """
390     if machineId is None:
391         raise CodeError("No machine ID specified")
392     try:
393         machineId = int(machineId)
394     except ValueError:
395         raise CodeError("Invalid machine ID '%s'" % machineId)
396     machine = Machine.get(machineId)
397     if exists and machine is None:
398         raise CodeError("No such machine ID '%s'" % machineId)
399     if machine is not None and not haveAccess(user, machine):
400         raise CodeError("No access to machine ID '%s'" % machineId)
401     return machine
402
403 def vnc(user, fields):
404     """VNC applet page.
405
406     Note that due to same-domain restrictions, the applet connects to
407     the webserver, which needs to forward those requests to the xen
408     server.  The Xen server runs another proxy that (1) authenticates
409     and (2) finds the correct port for the VM.
410
411     You might want iptables like:
412
413     -t nat -A PREROUTING -s ! 18.181.0.60 -i eth1 -p tcp -m tcp --dport 10003 -j DNAT --to-destination 18.181.0.60:10003 
414     -t nat -A POSTROUTING -d 18.181.0.60 -o eth1 -p tcp -m tcp --dport 10003 -j SNAT --to-source 18.187.7.142 
415     -A FORWARD -d 18.181.0.60 -i eth1 -o eth1 -p tcp -m tcp --dport 10003 -j ACCEPT
416
417     Remember to enable iptables!
418     echo 1 > /proc/sys/net/ipv4/ip_forward
419     """
420     machine = testMachineId(user, fields.getfirst('machine_id'))
421     
422     TOKEN_KEY = "0M6W0U1IXexThi5idy8mnkqPKEq1LtEnlK/pZSn0cDrN"
423
424     data = {}
425     data["user"] = user.username
426     data["machine"]=machine.name
427     data["expires"]=time.time()+(5*60)
428     pickledData = cPickle.dumps(data)
429     m = hmac.new(TOKEN_KEY, digestmod=sha)
430     m.update(pickledData)
431     token = {'data': pickledData, 'digest': m.digest()}
432     token = cPickle.dumps(token)
433     token = base64.urlsafe_b64encode(token)
434     
435     d = dict(user=user,
436              machine=machine,
437              hostname=os.environ.get('SERVER_NAME', 'localhost'),
438              authtoken=token)
439     print Template(file='vnc.tmpl',
440                    searchList=[d, global_dict])
441
442 def getNicInfo(data_dict, machine):
443     """Helper function for info, get data on nics for a machine.
444
445     Modifies data_dict to include the relevant data, and returns a list
446     of (key, name) pairs to display "name: data_dict[key]" to the user.
447     """
448     data_dict['num_nics'] = len(machine.nics)
449     nic_fields_template = [('nic%s_hostname', 'NIC %s hostname'),
450                            ('nic%s_mac', 'NIC %s MAC Addr'),
451                            ('nic%s_ip', 'NIC %s IP'),
452                            ]
453     nic_fields = []
454     for i in range(len(machine.nics)):
455         nic_fields.extend([(x % i, y % i) for x, y in nic_fields_template])
456         data_dict['nic%s_hostname' % i] = machine.nics[i].hostname + '.servers.csail.mit.edu'
457         data_dict['nic%s_mac' % i] = machine.nics[i].mac_addr
458         data_dict['nic%s_ip' % i] = machine.nics[i].ip
459     if len(machine.nics) == 1:
460         nic_fields = [(x, y.replace('NIC 0 ', '')) for x, y in nic_fields]
461     return nic_fields
462
463 def getDiskInfo(data_dict, machine):
464     """Helper function for info, get data on disks for a machine.
465
466     Modifies data_dict to include the relevant data, and returns a list
467     of (key, name) pairs to display "name: data_dict[key]" to the user.
468     """
469     data_dict['num_disks'] = len(machine.disks)
470     disk_fields_template = [('%s_size', '%s size')]
471     disk_fields = []
472     for disk in machine.disks:
473         name = disk.guest_device_name
474         disk_fields.extend([(x % name, y % name) for x, y in disk_fields_template])
475         data_dict['%s_size' % name] = "%0.1f GB" % (disk.size / 1024.)
476     return disk_fields
477
478 def deleteVM(machine):
479     """Delete a VM."""
480     transaction = ctx.current.create_transaction()
481     delete_disk_pairs = [(machine.name, d.guest_device_name) for d in machine.disks]
482     try:
483         for nic in machine.nics:
484             nic.machine_id = None
485             nic.hostname = None
486             ctx.current.save(nic)
487         for disk in machine.disks:
488             ctx.current.delete(disk)
489         ctx.current.delete(machine)
490         transaction.commit()
491     except:
492         transaction.rollback()
493         raise
494     for mname, dname in delete_disk_pairs:
495         remctl('web', 'lvremove', mname, dname)
496     unregisterMachine(machine)
497
498 def command(user, fields):
499     """Handler for running commands like boot and delete on a VM."""
500     print time.time()-start_time
501     machine = testMachineId(user, fields.getfirst('machine_id'))
502     action = fields.getfirst('action')
503     cdrom = fields.getfirst('cdrom')
504     print time.time()-start_time
505     if cdrom is not None and not CDROM.get(cdrom):
506         raise CodeError("Invalid cdrom type '%s'" % cdrom)    
507     if action not in ('Reboot', 'Power on', 'Power off', 'Shutdown', 'Delete VM'):
508         raise CodeError("Invalid action '%s'" % action)
509     if action == 'Reboot':
510         if cdrom is not None:
511             remctl('reboot', machine.name, cdrom)
512         else:
513             remctl('reboot', machine.name)
514     elif action == 'Power on':
515         if maxMemory(user) < machine.memory:
516             raise InvalidInput("You don't have enough free RAM quota")
517         bootMachine(machine, cdrom)
518     elif action == 'Power off':
519         remctl('destroy', machine.name)
520     elif action == 'Shutdown':
521         remctl('shutdown', machine.name)
522     elif action == 'Delete VM':
523         deleteVM(machine)
524     print time.time()-start_time
525
526     d = dict(user=user,
527              command=action,
528              machine=machine)
529     print Template(file="command.tmpl", searchList=[d, global_dict])
530         
531 def modify(user, fields):
532     """Handler for modifying attributes of a machine."""
533     #XXX not written yet
534     machine = testMachineId(user, fields.getfirst('machine_id'))
535     
536 def help(user, fields):
537     """Handler for help messages."""
538     simple = fields.getfirst('simple')
539     subjects = fields.getlist('subject')
540     
541     mapping = dict(paravm_console="""
542 ParaVM machines do not support console access over VNC.  To access
543 these machines, you either need to boot with a liveCD and ssh in or
544 hope that the sipb-xen maintainers add support for serial consoles.""",
545                    hvm_paravm="""
546 HVM machines use the virtualization features of the processor, while
547 ParaVM machines use Xen's emulation of virtualization features.  You
548 want an HVM virtualized machine.""",
549                    cpu_weight="""Don't ask us!  We're as mystified as you are.""")
550     
551     d = dict(user=user,
552              simple=simple,
553              subjects=subjects,
554              mapping=mapping)
555     
556     print Template(file="help.tmpl", searchList=[d, global_dict])
557     
558
559 def info(user, fields):
560     """Handler for info on a single VM."""
561     machine = testMachineId(user, fields.getfirst('machine_id'))
562     status = statusInfo(machine)
563     has_vnc = hasVnc(status)
564     if status is None:
565         main_status = dict(name=machine.name,
566                            memory=str(machine.memory))
567     else:
568         main_status = dict(status[1:])
569     start_time = float(main_status.get('start_time', 0))
570     uptime = datetime.timedelta(seconds=int(time.time()-start_time))
571     cpu_time_float = float(main_status.get('cpu_time', 0))
572     cputime = datetime.timedelta(seconds=int(cpu_time_float))
573     display_fields = """name uptime memory state cpu_weight on_reboot 
574      on_poweroff on_crash on_xend_start on_xend_stop bootloader""".split()
575     display_fields = [('name', 'Name'),
576                       ('owner', 'Owner'),
577                       ('contact', 'Contact'),
578                       ('type', 'Type'),
579                       'NIC_INFO',
580                       ('uptime', 'uptime'),
581                       ('cputime', 'CPU usage'),
582                       ('memory', 'RAM'),
583                       'DISK_INFO',
584                       ('state', 'state (xen format)'),
585                       ('cpu_weight', 'CPU weight'+helppopup('cpu_weight')),
586                       ('on_reboot', 'Action on VM reboot'),
587                       ('on_poweroff', 'Action on VM poweroff'),
588                       ('on_crash', 'Action on VM crash'),
589                       ('on_xend_start', 'Action on Xen start'),
590                       ('on_xend_stop', 'Action on Xen stop'),
591                       ('bootloader', 'Bootloader options'),
592                       ]
593     fields = []
594     machine_info = {}
595     machine_info['type'] = machine.type.hvm and 'HVM' or 'ParaVM'
596     machine_info['owner'] = machine.owner
597     machine_info['contact'] = machine.contact
598
599     nic_fields = getNicInfo(machine_info, machine)
600     nic_point = display_fields.index('NIC_INFO')
601     display_fields = display_fields[:nic_point] + nic_fields + display_fields[nic_point+1:]
602
603     disk_fields = getDiskInfo(machine_info, machine)
604     disk_point = display_fields.index('DISK_INFO')
605     display_fields = display_fields[:disk_point] + disk_fields + display_fields[disk_point+1:]
606     
607     main_status['memory'] += ' MB'
608     for field, disp in display_fields:
609         if field in ('uptime', 'cputime'):
610             fields.append((disp, locals()[field]))
611         elif field in main_status:
612             fields.append((disp, main_status[field]))
613         elif field in machine_info:
614             fields.append((disp, machine_info[field]))
615         else:
616             pass
617             #fields.append((disp, None))
618     max_mem = maxMemory(user, machine)
619     max_disk = maxDisk(user, machine)
620     d = dict(user=user,
621              cdroms=CDROM.select(),
622              on=status is not None,
623              machine=machine,
624              has_vnc=has_vnc,
625              uptime=str(uptime),
626              ram=machine.memory,
627              max_mem=max_mem,
628              max_disk=max_disk,
629              fields = fields)
630     print Template(file='info.tmpl',
631                    searchList=[d, global_dict])
632
633 mapping = dict(list=listVms,
634                vnc=vnc,
635                command=command,
636                modify=modify,
637                info=info,
638                create=create,
639                help=help)
640
641 if __name__ == '__main__':
642     start_time = time.time()
643     fields = cgi.FieldStorage()
644     class User:
645         username = "moo"
646         email = 'moo@cow.com'
647     u = User()
648     if 'SSL_CLIENT_S_DN_Email' in os.environ:
649         username = os.environ[ 'SSL_CLIENT_S_DN_Email'].split("@")[0]
650         u.username = username
651         u.email = os.environ[ 'SSL_CLIENT_S_DN_Email']
652     else:
653         u.username = 'moo'
654         u.email = 'nobody'
655     connect('postgres://sipb-xen@sipb-xen-dev/sipb_xen')
656     operation = os.environ.get('PATH_INFO', '')
657     #print 'Content-Type: text/plain\n'
658     #print operation
659     if not operation:
660         print "Status: 301 Moved Permanently"
661         print 'Location: ' + os.environ['SCRIPT_NAME']+'/\n'
662         sys.exit(0)
663     print 'Content-Type: text/html\n'
664
665     if operation.startswith('/'):
666         operation = operation[1:]
667     if not operation:
668         operation = 'list'
669     
670     fun = mapping.get(operation, 
671                       lambda u, e:
672                           error(operation, u, e,
673                                 "Invalid operation '%s'" % operation))
674     if fun not in (help, ):
675         connect('postgres://sipb-xen@sipb-xen-dev/sipb_xen')
676     try:
677         fun(u, fields)
678     except CodeError, err:
679         error(operation, u, fields, err)
680     except InvalidInput, err:
681         error(operation, u, fields, err)