36518d67f99d10232dcf6bf4e693847dc0040a84
[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 print 'Content-Type: text/html\n'
17 sys.stderr = sys.stdout
18 sys.path.append('/home/ecprice/.local/lib/python2.5/site-packages')
19
20 from Cheetah.Template import Template
21 from sipb_xen_database import *
22 import random
23
24 class MyException(Exception):
25     pass
26
27 # ... and stolen from xend/uuid.py
28 def randomUUID():
29     """Generate a random UUID."""
30
31     return [ random.randint(0, 255) for _ in range(0, 16) ]
32
33 def uuidToString(u):
34     return "-".join(["%02x" * 4, "%02x" * 2, "%02x" * 2, "%02x" * 2,
35                      "%02x" * 6]) % tuple(u)
36
37 def maxMemory(user, machine=None):
38     return 256
39
40 def maxDisk(user, machine=None):
41     return 10.0
42
43 def haveAccess(user, machine):
44     return True
45
46 def error(op, user, fields, err):
47     d = dict(op=op, user=user, errorMessage=str(err))
48     print Template(file='error.tmpl', searchList=d);
49
50 def validMachineName(name):
51     """Check that name is valid for a machine name"""
52     if not name:
53         return False
54     charset = string.ascii_letters + string.digits + '-_'
55     if name[0] in '-_' or len(name) > 22:
56         return False
57     return all(x in charset for x in name)
58
59 def kinit(username = 'tabbott/extra', keytab = '/etc/tabbott.keytab'):
60     """Kinit with a given username and keytab"""
61
62     p = subprocess.Popen(['kinit', "-k", "-t", keytab, username],
63                          stderr=subprocess.PIPE)
64     e = p.wait()
65     if e:
66         raise MyException("Error %s in kinit: %s" % (e, p.stderr.read()))
67
68 def checkKinit():
69     """If we lack tickets, kinit."""
70     p = subprocess.Popen(['klist', '-s'])
71     if p.wait():
72         kinit()
73
74 def remctl(*args, **kws):
75     """Perform a remctl and return the output.
76
77     kinits if necessary, and outputs errors to stderr.
78     """
79     checkKinit()
80     p = subprocess.Popen(['remctl', 'black-mesa.mit.edu']
81                          + list(args),
82                          stdout=subprocess.PIPE,
83                          stderr=subprocess.PIPE)
84     if kws.get('err'):
85         return p.stdout.read(), p.stderr.read()
86     if p.wait():
87         print >> sys.stderr, 'ERROR on remctl ', args
88         print >> sys.stderr, p.stderr.read()
89     return p.stdout.read()
90
91 def makeDisks():
92     """Update the lvm partitions to include all disks in the database."""
93     remctl('web', 'lvcreate')
94
95 def bootMachine(machine, cdtype):
96     """Boot a machine with a given boot CD.
97
98     If cdtype is None, give no boot cd.  Otherwise, it is the string
99     id of the CD (e.g. 'gutsy_i386')
100     """
101     if cdtype is not None:
102         remctl('web', 'vmboot', machine.name,
103                cdtype)
104     else:
105         remctl('web', 'vmboot', machine.name)
106
107 def registerMachine(machine):
108     """Register a machine to be controlled by the web interface"""
109     remctl('web', 'register', machine.name)
110
111 def unregisterMachine(machine):
112     """Unregister a machine to not be controlled by the web interface"""
113     remctl('web', 'unregister', machine.name)
114
115 def parseStatus(s):
116     """Parse a status string into nested tuples of strings.
117
118     s = output of xm list --long <machine_name>
119     """
120     values = re.split('([()])', s)
121     stack = [[]]
122     for v in values[2:-2]: #remove initial and final '()'
123         if not v:
124             continue
125         v = v.strip()
126         if v == '(':
127             stack.append([])
128         elif v == ')':
129             if len(stack[-1]) == 1:
130                 stack[-1].append('')
131             stack[-2].append(stack[-1])
132             stack.pop()
133         else:
134             if not v:
135                 continue
136             stack[-1].extend(v.split())
137     return stack[-1]
138
139 def getUptimes(machines):
140     """Return a dictionary mapping machine names to uptime strings"""
141     value_string = remctl('web', 'listvms')
142     lines = value_string.splitlines()
143     d = {}
144     for line in lines[1:]:
145         lst = line.split()
146         name, id = lst[:2]
147         uptime = ' '.join(lst[2:])
148         d[name] = uptime
149     return d
150
151 def statusInfo(machine):
152     """Return the status list for a given machine.
153
154     Gets and parses xm list --long
155     """
156     value_string, err_string = remctl('list-long', machine.name, err=True)
157     if 'Unknown command' in err_string:
158         raise MyException("ERROR in remctl list-long %s is not registered" % (machine.name,))
159     elif 'does not exist' in err_string:
160         return None
161     elif err_string:
162         raise MyException("ERROR in remctl list-long %s:  %s" % (machine.name, err_string))
163     status = parseStatus(value_string)
164     return status
165
166 def hasVnc(status):
167     """Does the machine with a given status list support VNC?"""
168     if status is None:
169         return False
170     for l in status:
171         if l[0] == 'device' and l[1][0] == 'vfb':
172             d = dict(l[1][1:])
173             return 'location' in d
174     return False
175
176 def createVm(user, name, memory, disk, is_hvm, cdrom):
177     """Create a VM and put it in the database"""
178     # put stuff in the table
179     transaction = ctx.current.create_transaction()
180     try:
181         res = meta.engine.execute('select nextval(\'"machines_machine_id_seq"\')')
182         id = res.fetchone()[0]
183         machine = Machine()
184         machine.machine_id = id
185         machine.name = name
186         machine.memory = memory
187         machine.owner = user.username
188         machine.contact = user.email
189         machine.uuid = uuidToString(randomUUID())
190         machine.boot_off_cd = True
191         machine_type = Type.get_by(hvm=is_hvm)
192         machine.type_id = machine_type.type_id
193         ctx.current.save(machine)
194         disk = Disk(machine.machine_id, 
195                     'hda', disk)
196         open = NIC.select_by(machine_id=None)
197         if not open: #No IPs left!
198             return "No IP addresses left!  Contact sipb-xen-dev@mit.edu"
199         nic = open[0]
200         nic.machine_id = machine.machine_id
201         nic.hostname = name
202         ctx.current.save(nic)    
203         ctx.current.save(disk)
204         transaction.commit()
205     except:
206         transaction.rollback()
207         raise
208     makeDisks()
209     registerMachine(machine)
210     # tell it to boot with cdrom
211     bootMachine(machine, cdrom)
212
213     return machine
214
215 def validMemory(user, memory, machine=None):
216     try:
217         memory = int(memory)
218         if memory <= 0:
219             raise ValueError
220     except ValueError:
221         raise MyException("Invalid memory amount")
222     if memory > maxMemory(user, machine):
223         raise MyException("Too much memory requested")
224     return memory
225
226 def validDisk(user, disk, machine=None):
227     try:
228         disk = float(disk)
229         if disk > maxDisk(user, machine):
230             raise MyException("Too much disk requested")
231         disk = int(disk * 1024)
232         if disk <= 0:
233             raise ValueError
234     except ValueError:
235         raise MyException("Invalid disk amount")
236     return disk
237
238 def create(user, fields):
239     name = fields.getfirst('name')
240     if not validMachineName(name):
241         raise MyException("Invalid name '%s'" % name)
242     name = user.username + '_' + name.lower()
243
244     if Machine.get_by(name=name):
245         raise MyException("A machine named '%s' already exists" % name)
246     
247     memory = fields.getfirst('memory')
248     memory = validMemory(user, memory)
249     
250     disk = fields.getfirst('disk')
251     disk = validDisk(user, disk)
252
253     vm_type = fields.getfirst('vmtype')
254     if vm_type not in ('hvm', 'paravm'):
255         raise MyException("Invalid vm type '%s'"  % vm_type)    
256     is_hvm = (vm_type == 'hvm')
257
258     cdrom = fields.getfirst('cdrom')
259     if cdrom is not None and not CDROM.get(cdrom):
260         raise MyException("Invalid cdrom type '%s'" % cdrom)    
261     
262     machine = createVm(user, name, memory, disk, is_hvm, cdrom)
263     if isinstance(machine, basestring):
264         raise MyException(machine)
265     d = dict(user=user,
266              machine=machine)
267     print Template(file='create.tmpl',
268                    searchList=d);
269
270 def listVms(user, fields):
271     machines = Machine.select()
272     on = {}
273     has_vnc = {}
274     uptimes = getUptimes(machines)
275     on = has_vnc = uptimes
276     #     for m in machines:
277     #         status = statusInfo(m)
278     #         on[m.name] = status is not None
279     #         has_vnc[m.name] = hasVnc(status)
280     d = dict(user=user,
281              maxmem=maxMemory(user),
282              maxdisk=maxDisk(user),
283              machines=machines,
284              has_vnc=has_vnc,
285              uptimes=uptimes,
286              cdroms=CDROM.select())
287     print Template(file='list.tmpl', searchList=d)
288
289 def testMachineId(user, machineId, exists=True):
290     if machineId is None:
291         raise MyException("No machine ID specified")
292     try:
293         machineId = int(machineId)
294     except ValueError:
295         raise MyException("Invalid machine ID '%s'" % machineId)
296     machine = Machine.get(machineId)
297     if exists and machine is None:
298         raise MyException("No such machine ID '%s'" % machineId)
299     if not haveAccess(user, machine):
300         raise MyException("No access to machine ID '%s'" % machineId)
301     return machine
302
303 def vnc(user, fields):
304     """VNC applet page.
305
306     Note that due to same-domain restrictions, the applet connects to
307     the webserver, which needs to forward those requests to the xen
308     server.  The Xen server runs another proxy that (1) authenticates
309     and (2) finds the correct port for the VM.
310
311     You might want iptables like:
312
313     -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 
314     -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 
315     -A FORWARD -d 18.181.0.60 -i eth1 -o eth1 -p tcp -m tcp --dport 10003 -j ACCEPT
316     """
317     machine = testMachineId(user, fields.getfirst('machine_id'))
318     #XXX fix
319     
320     TOKEN_KEY = "0M6W0U1IXexThi5idy8mnkqPKEq1LtEnlK/pZSn0cDrN"
321
322     data = {}
323     data["user"] = user.username
324     data["machine"]=machine.name
325     data["expires"]=time.time()+(5*60)
326     pickledData = cPickle.dumps(data)
327     m = hmac.new(TOKEN_KEY, digestmod=sha)
328     m.update(pickledData)
329     token = {'data': pickledData, 'digest': m.digest()}
330     token = cPickle.dumps(token)
331     token = base64.urlsafe_b64encode(token)
332     
333     d = dict(user=user,
334              machine=machine,
335              hostname=os.environ.get('SERVER_NAME', 'localhost'),
336              authtoken=token)
337     print Template(file='vnc.tmpl',
338                    searchList=d)
339
340 def getNicInfo(data_dict, machine):
341     data_dict['num_nics'] = len(machine.nics)
342     nic_fields_template = [('nic%s_hostname', 'NIC %s hostname'),
343                            ('nic%s_mac', 'NIC %s MAC Addr'),
344                            ('nic%s_ip', 'NIC %s IP'),
345                            ]
346     nic_fields = []
347     for i in range(len(machine.nics)):
348         nic_fields.extend([(x % i, y % i) for x, y in nic_fields_template])
349         data_dict['nic%s_hostname' % i] = machine.nics[i].hostname + '.servers.csail.mit.edu'
350         data_dict['nic%s_mac' % i] = machine.nics[i].mac_addr
351         data_dict['nic%s_ip' % i] = machine.nics[i].ip
352     if len(machine.nics) == 1:
353         nic_fields = [(x, y.replace('NIC 0 ', '')) for x, y in nic_fields]
354     return nic_fields
355
356 def getDiskInfo(data_dict, machine):
357     data_dict['num_disks'] = len(machine.disks)
358     disk_fields_template = [('%s_size', '%s size')]
359     disk_fields = []
360     for disk in machine.disks:
361         name = disk.guest_device_name
362         disk_fields.extend([(x % name, y % name) for x, y in disk_fields_template])
363         data_dict['%s_size' % name] = "%0.1f GB" % (disk.size / 1024.)
364     return disk_fields
365
366 def deleteVM(machine):
367     transaction = ctx.current.create_transaction()
368     delete_disk_pairs = [(machine.name, d.guest_device_name) for d in machine.disks]
369     try:
370         for nic in machine.nics:
371             nic.machine_id = None
372             nic.hostname = None
373             ctx.current.save(nic)
374         for disk in machine.disks:
375             ctx.current.delete(disk)
376         ctx.current.delete(machine)
377         transaction.commit()
378     except:
379         transaction.rollback()
380         raise
381     for mname, dname in delete_disk_pairs:
382         remctl('web', 'lvremove', mname, dname)
383     unregisterMachine(machine)
384
385 def command(user, fields):
386     print time.time()-start_time
387     machine = testMachineId(user, fields.getfirst('machine_id'))
388     action = fields.getfirst('action')
389     cdrom = fields.getfirst('cdrom')
390     print time.time()-start_time
391     if cdrom is not None and not CDROM.get(cdrom):
392         raise MyException("Invalid cdrom type '%s'" % cdrom)    
393     if action not in ('Reboot', 'Power on', 'Power off', 'Shutdown', 'Delete VM'):
394         raise MyException("Invalid action '%s'" % action)
395     if action == 'Reboot':
396         if cdrom is not None:
397             remctl('reboot', machine.name, cdrom)
398         else:
399             remctl('reboot', machine.name)
400     elif action == 'Power on':
401         bootMachine(machine, cdrom)
402     elif action == 'Power off':
403         remctl('destroy', machine.name)
404     elif action == 'Shutdown':
405         remctl('shutdown', machine.name)
406     elif action == 'Delete VM':
407         deleteVM(machine)
408     print time.time()-start_time
409
410     d = dict(user=user,
411              command=action,
412              machine=machine)
413     print Template(file="command.tmpl", searchList=d)
414         
415 def modify(user, fields):
416     machine = testMachineId(user, fields.getfirst('machine_id'))
417     
418
419 def info(user, fields):
420     machine = testMachineId(user, fields.getfirst('machine_id'))
421     status = statusInfo(machine)
422     has_vnc = hasVnc(status)
423     if status is None:
424         main_status = dict(name=machine.name,
425                            memory=str(machine.memory))
426     else:
427         main_status = dict(status[1:])
428     start_time = float(main_status.get('start_time', 0))
429     uptime = datetime.timedelta(seconds=int(time.time()-start_time))
430     cpu_time_float = float(main_status.get('cpu_time', 0))
431     cputime = datetime.timedelta(seconds=int(cpu_time_float))
432     display_fields = """name uptime memory state cpu_weight on_reboot 
433      on_poweroff on_crash on_xend_start on_xend_stop bootloader""".split()
434     display_fields = [('name', 'Name'),
435                       ('owner', 'Owner'),
436                       ('contact', 'Contact'),
437                       'NIC_INFO',
438                       ('uptime', 'uptime'),
439                       ('cputime', 'CPU usage'),
440                       ('memory', 'RAM'),
441                       'DISK_INFO',
442                       ('state', 'state (xen format)'),
443                       ('cpu_weight', 'CPU weight'),
444                       ('on_reboot', 'Action on VM reboot'),
445                       ('on_poweroff', 'Action on VM poweroff'),
446                       ('on_crash', 'Action on VM crash'),
447                       ('on_xend_start', 'Action on Xen start'),
448                       ('on_xend_stop', 'Action on Xen stop'),
449                       ('bootloader', 'Bootloader options'),
450                       ]
451     fields = []
452     machine_info = {}
453     machine_info['owner'] = machine.owner
454     machine_info['contact'] = machine.contact
455
456     nic_fields = getNicInfo(machine_info, machine)
457     nic_point = display_fields.index('NIC_INFO')
458     display_fields = display_fields[:nic_point] + nic_fields + display_fields[nic_point+1:]
459
460     disk_fields = getDiskInfo(machine_info, machine)
461     disk_point = display_fields.index('DISK_INFO')
462     display_fields = display_fields[:disk_point] + disk_fields + display_fields[disk_point+1:]
463     
464     main_status['memory'] += ' MB'
465     for field, disp in display_fields:
466         if field in ('uptime', 'cputime'):
467             fields.append((disp, locals()[field]))
468         elif field in main_status:
469             fields.append((disp, main_status[field]))
470         elif field in machine_info:
471             fields.append((disp, machine_info[field]))
472         else:
473             pass
474             #fields.append((disp, None))
475
476     d = dict(user=user,
477              cdroms=CDROM.select(),
478              on=status is not None,
479              machine=machine,
480              has_vnc=has_vnc,
481              uptime=str(uptime),
482              ram=machine.memory,
483              maxmem=maxMemory(user, machine),
484              maxdisk=maxDisk(user, machine),
485              fields = fields)
486     print Template(file='info.tmpl',
487                    searchList=d)
488
489 mapping = dict(list=listVms,
490                vnc=vnc,
491                command=command,
492                modify=modify,
493                info=info,
494                create=create)
495
496 if __name__ == '__main__':
497     start_time = time.time()
498     fields = cgi.FieldStorage()
499     class User:
500         username = "moo"
501         email = 'moo@cow.com'
502     u = User()
503     connect('postgres://sipb-xen@sipb-xen-dev/sipb_xen')
504     operation = os.environ.get('PATH_INFO', '')
505     if not operation:
506         pass
507         #XXX do redirect
508
509     if operation.startswith('/'):
510         operation = operation[1:]
511     if not operation:
512         operation = 'list'
513     
514     fun = mapping.get(operation, 
515                       lambda u, e:
516                           error(operation, u, e,
517                                 "Invalid operation '%s'" % operation))
518     try:
519         fun(u, fields)
520     except MyException, err:
521         error(operation, u, fields, err)