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