def GET(request):
"""Get this Room's Tiles."""
# Make sure required parameters are there
try:
request.check_required_parameters(path={'roomId': 'int'})
except exceptions.ParameterError as e:
return Response(400, e.message)
# Instantiate a Room from the database
room = Room.from_primary_key((request.params_path['roomId'], ))
# Make sure this Room exists
if not room.exists():
return Response(404, '{} not found.'.format(room))
# Make sure this user is authorized to view this Room's Tiles
if not room.google_id_has_at_least(request.google_id, 'VIEW'):
return Response(403,
'Forbidden from viewing Tiles for {}.'.format(room))
# Get and return the Tiles
tiles = Tile.query('room_id', room.id)
for tile in tiles:
tile.read()
return Response(200, 'Successfully retrieved Tiles for {}.'.format(room),
[x.to_JSON() for x in tiles])
def from_tile_id(cls, tile_id):
"""Get a Rack from the ID of the Tile it's on."""
tile = Tile.from_primary_key((tile_id, ))
if not tile.exists():
return Rack(id=-1)
return cls.from_primary_key((tile.object_id, ))
def PUT(request):
"""Update the Rack on this Tile."""
# Make sure required parameters are there
try:
request.check_required_parameters(path={'tileId': 'int'},
body={
'rack': {
'name': 'string',
'capacity': 'int',
'powerCapacityW': 'int'
}
})
except exceptions.ParameterError as e:
return Response(400, e.message)
# Instantiate a Tile from the database
tile = Tile.from_primary_key((request.params_path['tileId'], ))
# Make sure this Tile exists
if not tile.exists():
return Response(404, '{} not found.'.format(tile))
# Make sure this user is authorized to edit this Tile
if not tile.google_id_has_at_least(request.google_id, 'EDIT'):
return Response(403, 'Forbidden from editing {}'.format(tile))
# Instantiate a Rack from the database
rack = Rack.from_primary_key((tile.object_id, ))
# Make sure this Rack exists
if not rack.exists():
return Response(404, '{} not found'.format(rack))
# Update this Rack
rack.name = request.params_body['rack']['name']
rack.capacity = request.params_body['rack']['capacity']
rack.update()
# Return this Rack
rack.read()
return Response(200, 'Successfully updated {}.'.format(rack),
rack.to_JSON())
def POST(request):
"""Add a Rack to this Tile if it is empty."""
# Make sure required parameters are there
try:
request.check_required_parameters(path={'tileId': 'int'},
body={
'rack': {
'name': 'string',
'capacity': 'int',
'powerCapacityW': 'int'
}
})
except exceptions.ParameterError as e:
return Response(400, e.message)
# Instantiate a Tile from the database
tile = Tile.from_primary_key((request.params_path['tileId'], ))
# Make sure this Tile exists
if not tile.exists():
return Response(404, '{} not found.'.format(tile))
# Make sure this user is authorized to edit this Tile
if not tile.google_id_has_at_least(request.google_id, 'EDIT'):
return Response(403, 'Forbidden from editing {}'.format(tile))
# Make sure this Tile isn't occupied
if tile.object_id is not None:
return Response(409, '{} occupied.'.format(tile))
# Instantiate a Rack and insert it into the database
rack = Rack.from_JSON(request.params_body['rack'])
rack.insert()
# Try to add this Rack to this Tile
tile.object_id = rack.id
tile.object_type = 'RACK'
tile.update()
# Return this Rack
rack.read()
return Response(200, 'Successfully added {}.'.format(rack), rack.to_JSON())
def google_id_has_at_least(self, google_id, authorization_level):
"""Return True if the user has at least the given auth level over this Rack."""
# Get the Tile
try:
tile = Tile.query('object_id', self.id)[0]
except:
return False
# Check the Tile's Authorization
return tile.google_id_has_at_least(google_id, authorization_level)
def DELETE(request):
"""Delete this Tile's Rack."""
# Make sure required parameters are there
try:
request.check_required_parameters(path={'tileId': 'int'}, )
except exceptions.ParameterError as e:
return Response(400, e.message)
# Instantiate a Tile from the database
tile = Tile.from_primary_key((request.params_path['tileId'], ))
# Make sure this Tile exists
if not tile.exists():
return Response(404, '{} not found.'.format(tile))
# Make sure this user is authorized to edit this Tile
if not tile.google_id_has_at_least(request.google_id, 'EDIT'):
return Response(403, 'Forbidden from editing {}'.format(tile))
# Instantiate a Rack from the database
rack = Rack.from_primary_key((tile.object_id, ))
# Make sure this Rack exists
if not rack.exists():
return Response(404, '{} not found'.format(rack))
# Remove this Rack from this Tile
tile.object_id = None
tile.object_type = None
tile.update()
# Delete this Rack
rack.delete()
# Return this Rack
return Response(200, 'Successfully deleted {}.'.format(rack),
rack.to_JSON())
def GET(request):
"""Get this Tile."""
# Make sure request parameters are there
try:
request.check_required_parameters(
path={
'tileId': 'int'
}
)
except exceptions.ParameterError as e:
return Response(400, e.message)
# Instantiate a Tile from the database
tile = Tile.from_primary_key((request.params_path['tileId'],))
# Make sure this Tile exists
if not tile.exists():
return Response(404, '{} not found.'.format(tile))
# Make sure this user is authorized to view this Tile
if not tile.google_id_has_at_least(request.google_id, 'VIEW'):
return Response(403, 'Forbidden from retrieving {}.'.format(tile))
# Return this Tile
tile.read()
return Response(
200,
'Successfully retrieved {}.'.format(tile),
tile.to_JSON()
)
def POST(request):
"""Create a new Path that branches off of this Path at the specified tick."""
# Make sure required parameters are there
try:
request.check_required_parameters(
path={'pathId': 'int'}, body={'section': {
'startTick': 'int'
}})
except exceptions.ParameterError as e:
return Response(400, e.message)
# Instantiate the current Path from the database
current_path = Path.from_primary_key((request.params_path['pathId'], ))
# Make sure the current Path exists
if not current_path.exists():
return Response(404, '{} not found.'.format(current_path))
# Make sure this user is authorized to branch off the current Path
if not current_path.google_id_has_at_least(request.google_id, 'EDIT'):
return Response(
403, 'Forbidden from branching off {}.'.format(current_path))
# Create the new Path
new_path = Path(simulation_id=current_path.simulation_id,
datetime_created=database.datetime_to_string(
datetime.now()))
new_path.insert()
# Get the current Path's sections and add them to the new Path if they're before the branch
current_sections = Section.query('path_id', current_path.id)
last_section = None
for current_section in current_sections:
if current_section.start_tick < request.params_body['section'][
'startTick'] or current_section.start_tick == 0:
new_section = Section(path_id=new_path.id,
datacenter_id=current_section.datacenter_id,
start_tick=current_section.start_tick)
new_section.insert()
last_section = current_section
# Make a deep copy of the last section's datacenter, its rooms, their tiles, etc.
path_parameters = {'simulationId': new_path.simulation_id}
# Copy the Datacenter
old_datacenter = Datacenter.from_primary_key(
(last_section.datacenter_id, ))
message = old_datacenter.generate_api_call(path_parameters, request.token)
response = Request(message).process()
path_parameters['datacenterId'] = response.content['id']
# Create the new last Section, with the IDs of the new Path and new Datacenter
if last_section.start_tick != 0:
new_section = Section(
path_id=new_path.id,
datacenter_id=path_parameters['datacenterId'],
start_tick=request.params_body['section']['startTick'])
new_section.insert()
else:
last_section.datacenter_id = path_parameters['datacenterId']
last_section.update()
# Copy the rest of the Datacenter, starting with the Rooms...
old_rooms = Room.query('datacenter_id', old_datacenter.id)
for old_room in old_rooms:
old_room.datacenter_id = path_parameters['datacenterId']
if old_room.topology_id is None:
old_room.topology_id = old_room.id
message = old_room.generate_api_call(path_parameters, request.token)
response = Request(message).process()
path_parameters['roomId'] = response.content['id']
# ... then the Tiles, ...
old_tiles = Tile.query('room_id', old_room.id)
for old_tile in old_tiles:
old_tile.room_id = path_parameters['roomId']
if old_tile.topology_id is None:
old_tile.topology_id = old_tile.id
message = old_tile.generate_api_call(path_parameters,
request.token)
response = Request(message).process()
path_parameters['tileId'] = response.content['id']
old_objects = Object.query('id', old_tile.object_id)
# ... then the Tile's Rack, ...
if len(old_objects) == 1 and old_objects[0].type == 'RACK':
old_rack = Rack.query('id', old_objects[0].id)[0]
if old_rack.topology_id is None:
old_rack.topology_id = old_rack.id
message = old_rack.generate_api_call(path_parameters,
request.token)
response = Request(message).process()
path_parameters['rackId'] = response.content['id']
# ... then the Rack's Machines ...
old_machines = Machine.query('rack_id', old_rack.id)
for old_machine in old_machines:
old_machine.read()
old_machine.rack_id = path_parameters['rackId']
if old_machine.topology_id is None:
old_machine.topology_id = old_machine.id
message = old_machine.generate_api_call(
path_parameters, request.token)
response = Request(message).process()
path_parameters['machineId'] = response.content['id']
# Return the new Path
return Response(200, 'Successfully created {}.'.format(new_path),
new_path.to_JSON())
def POST(request):
"""Add a Tile."""
# Make sure required parameters are there
try:
request.check_required_parameters(path={'roomId': 'int'},
body={
'tile': {
'roomId': 'int',
'positionX': 'int',
'positionY': 'int'
}
})
except exceptions.ParameterError as e:
return Response(400, e.message)
if request.params_path['roomId'] != request.params_body['tile']['roomId']:
return Response(400, 'ID mismatch')
# Instantiate a Room from the database
room = Room.from_primary_key((request.params_path['roomId'], ))
# Make sure this Room exists
if not room.exists():
return Response(404, '{} not found.'.format(room))
# Make sure this user is authorized to edit this Room's Tiles
if not room.google_id_has_at_least(request.google_id, 'EDIT'):
return Response(403, 'Forbidden from adding Tiles to {}.'.format(room))
# Clean the tile JSON
tile_json = request.params_body['tile']
tile_json['objectId'] = None
tile_json['objectType'] = None
# Instantiate a Tile
tile = Tile.from_JSON(tile_json)
# Try to insert this Tile
try:
tile.insert()
except exceptions.ForeignKeyError as e:
if e.message == 'OccupiedTilePosition':
return Response(409, 'Tile position occupied.')
elif e.message == 'InvalidTilePosition':
return Response(
400,
'Invalid Tile position (new Tiles must neighbor existing Tiles).'
)
# Return this Tile
tile.read()
return Response(200, 'Successfully added {}.'.format(tile), tile.to_JSON())