def get_friend_rooms():
rooms = map(lambda name: flask_redis.hgetall(name),
flask_redis.smembers("forresthill-rooms"))
rooms.sort(key=lambda x: x['key'])
friends = set()
if current_user.is_authenticated:
for room in rooms:
room_machines = flask_redis.lrange(room['key'] + "-machines", 0,
-1)
for machineName in room_machines:
machine = flask_redis.hgetall(machineName)
if current_user.has_friend(machine['user']):
uun = current_user.get_friend(machine['user'])
friends.add((uun, room['key'], room['name']))
friends = list(friends)
# uun -> name
names = ldap.get_names([f[0] for f in friends])
for i in range(len(friends)):
uun, b, c = friends[i]
if uun in names:
friends[i] = {
'uun': uun,
'name': names[uun],
'room_key': b,
'room_name': c
}
friends.sort(key=lambda x: x['name'])
return friends
def update():
content = request.json
try:
key = content['callback-key']
except Exception:
key = ""
if key not in flask_redis.lrange("authorised-key", 0, -1):
# HTTP 401 Not Authorised
print "******* CLIENT ATTEMPTED TO USE BAD KEY *******"
raise APIError("Given key is not an authorised API key")
pipe = flask_redis.pipeline()
try:
for machine in content['machines']:
host = machine['hostname']
user = machine['user']
ts = machine['timestamp']
status = machine['status']
pipe.hset(host, "user", user)
pipe.hset(host, "timestamp", ts)
pipe.hset(host, "status", status)
except Exception:
print("Malformed JSON content")
raise APIError("Malformed JSON content", status_code=400)
pipe.set("last-update", str(datetime.utcnow().isoformat()))
pipe.execute()
return jsonify(status="ok")
def schema_reset_room(pipe, site, room, dropFromSite=False):
roomKey = room + "-machines"
machines = flask_redis.lrange(roomKey, 0, -1)
if len(machines) > 0:
pipe.delete(*machines)
pipe.delete(roomKey)
pipe.delete(room)
if dropFromSite:
pipe.srem(site + '-rooms', room)
def map_routine(which_room):
room = flask_redis.hgetall(str(which_room))
room_machines = flask_redis.lrange(room['key'] + "-machines", 0, -1)
machines = {m: flask_redis.hgetall(m) for m in room_machines}
num_rows = max([int(machines[m]['row']) for m in machines])
num_cols = max([int(machines[m]['col']) for m in machines])
num_machines = len(machines.keys())
num_used = 0
rows = []
for r in xrange(0, num_rows+1):
unsorted_cells = []
for c in xrange(0, num_cols+1):
default_cell = {'hostname': None, 'col': c, 'row': r}
cell = [v for (k, v) in machines.iteritems() if int(v['row']) == r and int(v['col']) == c]
if not cell:
cell = default_cell
else:
cell = cell[0]
try:
if cell['user'] is not "":
num_used += 1
except Exception:
pass
unsorted_cells.append(cell)
cells = unsorted_cells
rows.append(cells)
num_free = num_machines - num_used
reserved = flask_redis.smembers('reserved-machines')
low_availability = num_free <= 0.3 * num_machines
date_format = "%Y-%m-%dT%H:%M:%S.%f"
last_update = datetime.strptime(flask_redis.get("last-update"),date_format)
last_update = last_update.strftime("%Y-%m-%d %H:%M:%S")
return {
"room" : room,
"rows" : rows,
"reserved" : reserved,
"num_free" : num_free,
"num_machines" : num_machines,
"low_availability" : low_availability,
"last_update" : last_update
}
def get_cascader_elsewhere_count(cascaders: List[str], notRoom: str) -> int:
rooms = filter(lambda name: name != notRoom,
flask_redis.smembers("forresthill-rooms"))
rooms = map(lambda name: flask_redis.hgetall(name), rooms)
count: int = 0
for room in rooms:
room_machines = flask_redis.lrange(room['key'] + "-machines", 0, -1)
for machineName in room_machines:
machine = flask_redis.hgetall(machineName)
if machine['user']:
uun = find_cascader(cascaders, machine['user'])
if uun:
count += 1
return count
def route_get_cascaders():
if current_user.is_disabled:
return jsonify([])
cascaders = get_cascaders()
rooms = map(lambda name: flask_redis.hgetall(name),
flask_redis.smembers("forresthill-rooms"))
result = []
for room in rooms:
room_machines = flask_redis.lrange(room['key'] + "-machines", 0, -1)
for machineName in room_machines:
machine = flask_redis.hgetall(machineName)
if machine['user']:
uun = find_cascader(cascaders, machine['user'])
if uun:
result.append({
'uun': uun,
'room': room['name'],
})
uuns = [f['uun'] for f in result]
# uun -> name
names = ldap.get_names(uuns)
# uun -> tagline
taglines = flask_redis.hmget("cascaders.taglines", uuns)
for i in range(len(result)):
uun = result[i]['uun']
if uun in names:
result[i]['name'] = names[uun]
result[i]['tagline'] = taglines[i]
return jsonify(result)
def map_routine(which_room):
room = flask_redis.hgetall(str(which_room))
room_machines = flask_redis.lrange(room['key'] + "-machines", 0, -1)
machines = {m: flask_redis.hgetall(m) for m in room_machines}
num_rows = max([int(machines[m]['row']) for m in machines])
num_cols = max([int(machines[m]['col']) for m in machines])
num_machines = len(machines.keys())
num_used = 0
rows = []
uuns = []
for r in xrange(0, num_rows + 1):
unsorted_cells = []
for c in xrange(0, num_cols + 1):
default_cell = {'hostname': None, 'col': c, 'row': r}
cell = [
v for (k, v) in machines.iteritems()
if int(v['row']) == r and int(v['col']) == c
]
if not cell:
cell = default_cell
else:
cell = cell[0]
try:
if cell['user'] is not "" or cell['status'] == "offline":
num_used += 1
except Exception:
pass
if 'user' in cell:
if cell['user'] == "":
del cell['user']
else:
uun = current_user.get_friend(cell['user'])
if uun:
uuns.append(uun)
cell["user"] = uun
else:
cell["user"] = "******"
unsorted_cells.append(cell)
cells = unsorted_cells
rows.append(cells)
uun_names = ldap.get_names(uuns)
for y in xrange(len(rows)):
for x in xrange(len(rows[y])):
cell = rows[y][x]
if "user" in cell:
uun = cell["user"]
if uun in uun_names:
rows[y][x]["friend"] = uun_names[uun]
num_free = num_machines - num_used
low_availability = num_free <= 0.3 * num_machines
date_format = "%Y-%m-%dT%H:%M:%S.%f"
last_update = datetime.strptime(flask_redis.get("last-update"),
date_format)
last_update = last_update.strftime("%Y-%m-%d %H:%M:%S")
# Annotate friends with "here" if they are here
room_key = room['key']
friends = get_friend_rooms()
friends_here, friends_elsewhere = (0, 0)
for i in range(len(friends)):
if friends[i]['room_key'] == room_key:
friends[i]['here'] = True
friends_here += 1
else:
friends_elsewhere += 1
return {
"friends": friends,
"friends_here_count": friends_here,
"friends_elsewhere_count": friends_elsewhere,
"room": room,
"rows": rows,
"num_free": num_free,
"num_machines": num_machines,
"low_availability": low_availability,
"last_update": last_update
}
def room_machines(which):
machines = flask_redis.lrange(which + "-machines", 0, -1)
print(machines)
return machines
def update_schema():
content = request.json
try:
key = content['callback-key']
except Exception:
key = ""
if key not in flask_redis.lrange("authorised-key", 0, -1):
# HTTP 401 Not Authorised
print("******* CLIENT ATTEMPTED TO USE BAD KEY *******")
raise APIError("Given key is not an authorised API key")
try:
sheetInput = content['machines']
except Exception:
raise APIError("no machines?")
try:
resetAll = content['resetAll'] == True
except Exception:
raise APIError("Expected resetAll key")
try:
dropOnly = content['dropOnly'] == True
except Exception:
raise APIError("Expected dropOnly key")
roomKeys = ['site', 'key', 'name']
pipe = flask_redis.pipeline()
sites = defaultdict(list)
for sheet in sheetInput:
preader = csv.reader(sheet['csv'].split('\r\n'), delimiter=',')
room = {}
machines = []
for rownumber, row in enumerate(preader):
for colnumber, cell_value in enumerate(row):
# handle header rows first
if rownumber == 0:
if colnumber < len(roomKeys):
expected = roomKeys[colnumber]
if expected != cell_value:
raise APIError(
"[Sheet %s] Invalid header '%s' in cols[%s], expected '%s"
% (sheet['name'], cell_value, colnumber,
expected))
continue
elif rownumber == 1:
if colnumber >= len(roomKeys):
continue
if cell_value == "":
raise APIError(
"[Sheet %s] Invalid value in col[%s] row[%s], expected non-empty string"
% (sheet['name'], colnumber, rownumber))
colName = roomKeys[colnumber]
room[colName] = cell_value
continue
elif rownumber == 2:
if cell_value != "":
raise APIError(
"[Sheet %s] Invalid value '%s' in rows[%s], expected empty row"
% (sheet['name'], cell_value, rownumber))
continue
hostname = cell_value.lower()
if hostname != "" and not dropOnly:
machines.append({
'hostname': hostname.replace(' (gpu)', ''),
'col': colnumber,
'row': rownumber -
3, # -3 required because first 3 rows are headers
'user': '',
'gpu': str(hostname.endswith(' (gpu)')),
'timestamp': '',
'status': 'offline',
'site': room['site'],
'room': room['key'],
})
# if we aren't resetting the entire schema, reset just this room first
if not resetAll:
schema_reset_room(pipe,
room['site'],
room['key'],
dropFromSite=True)
# if dropping only, continue
if dropOnly:
continue
# add site to list of sites
pipe.sadd('mapp.sites', room['site'])
# add room to site
pipe.sadd(room['site'] + '-rooms', room['key'])
# add room dict
pipe.hmset(room['key'], room)
# add room machine listing
pipe.lpush(room['key'] + '-machines',
*map(lambda m: m['hostname'], machines))
# add each machine
for m in machines:
pipe.hmset(m['hostname'], m)
sites[room['site']].append(room)
if resetAll:
schema_reset(site="forresthill")
pipe.execute()
return jsonify({'success': True})
from map import flask_redis, app, braintree
from flask import request, redirect, render_template
import random
import twilio.twiml
# Try adding your own number to this list!
dh_machines = flask_redis.lrange("drillhall-machines", 0, -1)
machines = {m: flask_redis.hgetall(m) for m in dh_machines}
num_rows = max([int(machines[m]['row']) for m in machines])
num_cols = max([int(machines[m]['col']) for m in machines])
people_in_labs = [v['user'] for (k, v) in machines.iteritems() if "user" in v]
rows = []
for r in xrange(0, num_rows + 1):
unsorted_cells = []
for c in xrange(0, num_cols + 1):
default_cell = {'hostname': None, 'col': c, 'row': r}
cell = [
v for (k, v) in machines.iteritems()
if int(v['row']) == r and int(v['col']) == c
]
if not cell:
cell = default_cell
else:
cell = cell[0]
unsorted_cells.append(cell)
cells = unsorted_cells
rows.append(cells)
allMachines = [
'venosa', 'trento', 'pavia', 'orlofsky', 'mereb', 'radames', 'vervecelli',
