def handshake_ack(message):
match = manager.get_match(message['match'])
if match == None:
app.logger.info("Tried to access to match: " + message['match'])
return
color = match.get_color(message['player'])
code = match.join_match(message['player'], message['sid'])
app.logger.info("[HANDSHAKE] ack received from " + message['sid'] + "C: " +
color)
if (code == 0 or code == 1 or code == 2 or code == 3):
match = manager.get_match(message['match'])
emit('chat', {'data': match.get_stack_as_string()}, room=request.sid)
out = match.get_outcome()
if out != None:
emit('ended', {
'cause': out.termination.value,
'winner': out.winner,
'result': out.result()
},
room=request.sid)
match.finish_match(out.termination.value, out.winner)
leave_room(request.sid)
join_room(message['match'])
matcher[message['sid']] = {
'code': message['match'],
'player': message['player']
}
emit('unlock', {'data': coder[code]}, room=message['match'])
emit('receive_movement', match.pack_data(), room=message['match'])
emit('chat', {'data': coder[code] + " CONNECTED"},
room=message['match'])
manager.update(match)
app.logger.info("PLAYER " + match.get_color(message['player']) +
" JOINED OKAY")
elif code == -4:
finish = match.get_finish_cause()
if finish == "draw":
emit('ended', {
'cause': 12,
'winer': "draw",
'result': "1/2-1/2"
},
room=request.sid)
else:
emit('ended', {
'cause': finish.termination.value,
'winner': finish.termination.winner,
'result': finish.termination.result()
},
room=request.sid)
else:
evt = Request(RequestType.ERROR,
match.get_name_from_code(message['player']),
"ERROR JOINING: INVALID PLAYER CODE")
match.push_event(evt)
emit('new_event', evt.get_json(), room=accountant.get_cpanel())
app.logger.info("ERROR JOINING: INVALID PLAYER CODE")
def post(self, user_id):
"""
Add a specific user to friend list, and
send a friend request to that user
"""
args = friendsParser.parse_args()
profile_id = args['profile_id']
if profile_id is None:
abort(400)
friend_profile = Profile.objects(id=profile_id).only('user').first()
if friend_profile is None:
abort(400)
# add the user to friend list
success = Friend.objects(user=user_id).only(
'friends_list').update_one(add_to_set__friends_list=profile_id)
if success is 0:
friends = Friend(user=user_id, friends_list=[profile_id])
friends.save()
# put the friend request to the user's request list
user_profile = Profile.objects(user=user_id).only('id').first()
success = Request.objects(user=friend_profile.user).update_one(
add_to_set__requests_list=user_profile)
if success is 0:
friend_request = Request(
user=friend_profile.user,
type='friends', requests_list=[user_profile])
friend_request.save()
return {'status': 'success', 'message':
'The user has been added to your friend list'}
def disconnect():
try:
app.logger.info("[DC] " + request.sid + " requesting disconnect")
match_code = matcher[request.sid]
match = manager.get_match(match_code['code'])
code = match.leave_match(match_code['player'])
if (code == 0 or code == 1):
leave_room(match_code['code'])
emit('chat', {
'data':
match.get_color(match_code['player']) + " DISCONNECTED"
},
room=match_code['code'])
app.logger.info("[DC] " + match.get_color(match_code['player']) +
" " + request.sid + " disconnected ok")
manager.update(match)
else:
evt = Request(RequestType.ERROR, request.sid,
"[DC] CODE NOT FOUND")
match.push_event(evt)
emit('new_event', evt.get_json(), room=accountant.get_cpanel())
app.logger.error("[DC] CODE NOT FOUND")
except:
app.logger.error("[DC] ERROR")
traceback.print_exc()
def admin(message):
match = manager.get_match(message['match'])
match.stop_timer()
app.logger.info(message['match'] + " " +
match.get_color(message['player']) + " REQUESTED ADMIN")
evt = Request(RequestType.ADMIN,
match.get_name_from_code(message['player']))
match.push_event(evt)
emit('new_event', evt.get_json(), room=accountant.get_cpanel())
emit('stop_timer', {}, room=message['match'])
def test_get_volunteers_own_requests_correctly(self):
session_id = 'sessionId'
volunteer_id = '5f7c2d96e48e242b81178822'
other_volunteer_id = '5f81ae36fa3b02a743177500'
volunteer = Volunteer('login', 'pw', 'first', 'last', volunteer_id)
self.volunteer_handler.active_user_sessions[session_id] = volunteer
request_1 = Request(requester='5f81ae776db502d353a84fdf',
status=RequestStatus.CREATED,
items=[],
volunteer=None)
request_2 = Request(requester='5f81ae776db502d353a84fdf',
status=RequestStatus.IN_PROGRESS,
items=[],
volunteer=volunteer_id,
submission_date=datetime.now())
request_3 = Request(requester='5f81ae776db502d353a84fdf',
status=RequestStatus.IN_PROGRESS,
items=[],
volunteer=other_volunteer_id,
submission_date=datetime.now())
request_1_id = self.requests_dao.store_one(request_1.to_db_object())
request_2_id = self.requests_dao.store_one(request_2.to_db_object())
request_3_id = self.requests_dao.store_one(request_3.to_db_object())
requests = self.request_handler.get_volunteers_own_requests(session_id)
self.assertEqual(len(requests), 1)
self.assertEqual(requests[0]['id'], request_2_id)
def test_submit_request_with_missing_delivery_address(self):
session_id = 'sessionId'
requester_id = '5f81ae776db502d353a84fdf'
requester = Requester('login', 'pw', 'first', 'last', requester_id)
self.requester_handler.active_user_sessions[session_id] = requester
request = Request(requester=requester_id,
status=RequestStatus.CREATED,
items=[],
volunteer=None)
request_id = self.requests_dao.store_one(request.to_db_object())
with self.assertRaises(MissingDeliveryAddressError):
self.request_handler.submit_request(request_id, session_id)
def test_accept_request_with_other_status_than_submitted(self):
session_id = 'sessionId'
volunteer = Volunteer('login', 'pw', 'first', 'last',
'5f81ae776db502d353a84fdf')
self.volunteer_handler.active_user_sessions[session_id] = volunteer
request = Request(requester='5f7c2d96e48e242b81178822',
status=RequestStatus.CREATED,
items=[],
volunteer=None)
request_id = self.requests_dao.store_one(request.to_db_object())
with self.assertRaises(UnexpectedRequestStatusError):
self.request_handler.accept_request(request_id, session_id)
def test_submit_request_with_other_status_than_created(self):
session_id = 'sessionId'
requester_id = '5f81ae776db502d353a84fdf'
requester = Requester('login', 'pw', 'first', 'last', requester_id)
self.requester_handler.active_user_sessions[session_id] = requester
request = Request(requester=requester_id,
status=RequestStatus.IN_PROGRESS,
items=[],
volunteer=None,
submission_date=datetime.now())
request_id = self.requests_dao.store_one(request.to_db_object())
with self.assertRaises(UnexpectedRequestStatusError):
self.request_handler.submit_request(request_id, session_id)
def test_add_request_to_time_frame_with_incorrect_time_frame_id(self):
session_id = 'someId'
volunteer_id = str(ObjectId())
volunteer = Volunteer('login', 'pw', 'first', 'last', volunteer_id)
self.volunteer_handler.active_user_sessions[session_id] = volunteer
request = Request(requester=str(ObjectId()),
status=RequestStatus.IN_PROGRESS,
items=[],
volunteer=volunteer_id)
request.id = self.requests_dao.store_one(request.to_db_object())
self.assertEqual(len(self.dao.get_all()), 0)
with self.assertRaises(ObjectIdNotFoundError):
self.time_frame_handler.add_request_to_time_frame(
str(ObjectId()), request.id, session_id)
def test_add_request_to_time_frame_correctly(self):
session_id = 'someId'
volunteer_id = str(ObjectId())
volunteer = Volunteer('login', 'pw', 'first', 'last', volunteer_id)
self.volunteer_handler.active_user_sessions[session_id] = volunteer
time_frame = TimeFrame(volunteer_id,
datetime.fromisoformat('2020-10-25 12:00:00'),
datetime.fromisoformat('2020-10-25 14:00:00'),
[])
time_frame.id = self.dao.store_one(time_frame.to_db_object())
request_1 = Request(requester=str(ObjectId()),
status=RequestStatus.IN_PROGRESS,
items=[],
volunteer=volunteer_id)
request_2 = Request(requester=str(ObjectId()),
status=RequestStatus.IN_PROGRESS,
items=[],
volunteer=volunteer_id)
request_1.id = self.requests_dao.store_one(request_1.to_db_object())
request_2.id = self.requests_dao.store_one(request_2.to_db_object())
self.time_frame_handler.add_request_to_time_frame(
time_frame.id, request_1.id, session_id)
self.time_frame_handler.add_request_to_time_frame(
time_frame.id, request_2.id, session_id)
time_frames = self.dao.get_time_frames_by_volunteer(volunteer_id)
self.assertEqual(len(time_frames), 1)
self.assertEqual(str(time_frames[0]['_id']), time_frame.id)
self.assertEqual(len(time_frames[0]['requests']), 2)
self.assertEqual(str(time_frames[0]['requests'][0]), request_1.id)
self.assertEqual(str(time_frames[0]['requests'][1]), request_2.id)
def test_get_open_requests_with_area_correctly(self):
volunteer_point = (60.195382, 24.938703)
closest_request_point = (60.195318, 24.940731)
second_closest_request_point = (60.193371, 24.943177)
out_of_range_request_point = (60.143397, 24.985745)
range = 1
session_id = 'sessionId'
volunteer = Volunteer('login', 'pw', 'first', 'last', 'userId')
self.volunteer_handler.active_user_sessions[session_id] = volunteer
out_of_range_request_date = datetime.fromisoformat(
'2020-10-25 13:03:55.792200')
second_closest_request_date = datetime.fromisoformat(
'2020-10-26 13:03:55.792200')
closest_request_date = datetime.fromisoformat(
'2020-10-27 13:03:55.792200')
closest_request = Request(requester='5f7c2d96e48e242b81178822',
status=RequestStatus.SUBMITTED,
items=[],
volunteer=None,
delivery_address=Address(
'', '', '', closest_request_point[0],
closest_request_point[1]),
submission_date=closest_request_date)
second_closest_request = Request(
requester='5f7c2d96e48e242b81178822',
status=RequestStatus.SUBMITTED,
items=[],
volunteer=None,
delivery_address=Address('', '', '',
second_closest_request_point[0],
second_closest_request_point[1]),
submission_date=second_closest_request_date)
out_of_range_request = Request(
requester='5f7c2d96e48e242b81178822',
status=RequestStatus.SUBMITTED,
items=[],
volunteer=None,
delivery_address=Address('', '', '', out_of_range_request_point[0],
out_of_range_request_point[1]),
submission_date=out_of_range_request_date)
closest_request_id = self.requests_dao.store_one(
closest_request.to_db_object())
second_closest_request_id = self.requests_dao.store_one(
second_closest_request.to_db_object())
out_of_range_request_id = self.requests_dao.store_one(
out_of_range_request.to_db_object())
area = {
'range': range,
'lat': volunteer_point[0],
'lng': volunteer_point[1]
}
requests = self.request_handler.get_open_requests(session_id, area)
self.assertEqual(len(requests), 2)
self.assertEqual(requests[0]['id'], second_closest_request_id)
self.assertEqual(requests[1]['id'], closest_request_id)
def test_accept_request_correctly(self):
session_id = 'sessionId'
volunteer_id = '5f7c2d96e48e242b81178822'
volunteer = Volunteer('login', 'pw', 'first', 'last', volunteer_id)
self.volunteer_handler.active_user_sessions[session_id] = volunteer
request = Request(requester='5f81ae776db502d353a84fdf',
status=RequestStatus.SUBMITTED,
items=[],
volunteer=None)
request_id = self.requests_dao.store_one(request.to_db_object())
self.request_handler.accept_request(request_id, session_id)
request = self.request_handler.from_db_object(
self.requests_dao.get_all()[0])
self.assertEqual(request.status, RequestStatus.IN_PROGRESS)
self.assertEqual(request.volunteer, volunteer_id)
def get(self, user_id):
print user_id
request = Request.objects(user=user_id).only('requests_list').first()
if request is None:
return {}
return requests_list_serialize(request.requests_list)
def post(self, user_id):
args = teamParser.parse_args()
profileID = args['profileID']
profile = Profile.objects(id=profileID).first()
request = Request.objects(user=user_id,type='invite').only('requests_list').first()
if request is None or profile is None:
raise InvalidUsage('Request is illegal')
team = profile.LOLTeam
success = request.update(pull__requests_list=profile)
if success is 0 or team is None or team.captain != profile:
raise InvalidUsage('Request is illegal')
profile = Profile.objects(user=user_id).first()
if profile.LOLTeam is not None:
raise InvalidUsage('Already joined a team')
try:
assert len(team.members) < 6
team.members.append(profile)
except:
raise InvalidUsage('Team is full', 403)
profile.LOLTeam = team
team.save()
profile.save()
rongcloudJoinGroup(profile.id,team.id,teamName)
return team_serialize(team)
def test_submit_request_of_other_requester(self):
session_id = 'sessionId'
requester_id = '5f81ae776db502d353a84fdf'
other_requester_id = '5f7c28c6e979c6a33a1f3f79'
requester = Requester('login', 'pw', 'first', 'last', requester_id)
self.requester_handler.active_user_sessions[session_id] = requester
request = Request(requester=other_requester_id,
status=RequestStatus.CREATED,
items=[],
volunteer=None)
request_id = self.requests_dao.store_one(request.to_db_object())
with self.assertRaises(UnauthorizedAccessError):
self.request_handler.submit_request(request_id, session_id)
self.assertEqual(
self.request_handler.from_db_object(
self.requests_dao.get_all()[0]).status, RequestStatus.CREATED)
def post(self, user_id):
"""
Accept the friend request
Add the user into friend list
Remove the request from friend request
"""
args = friendsParser.parse_args()
profile_id = args['profile_id']
if profile_id is None:
abort(400)
success = Request.objects(user=user_id).only(
'requests_list').update_one(pull__requests_list=profile_id)
if success is 0:
abort(400)
success = Friend.objects(user=user_id).only(
'friends_list').update_one(add_to_set__friends_list=profile_id)
if success is 0:
friends = Friend(user=user_id, friends_list=[profile_id])
friends.save()
return {'status': 'success', 'message':
'The user has been added to your friend list'}
def report(message):
try:
match = manager.get_match(message['match'])
match.stop_timer()
app.logger.info(message['match'] + " " +
match.get_color(message['player']) +
" REPORTED ILLEGAL")
evt = Request(RequestType.ILLEGAL,
match.get_name_from_code(message['player']))
app.logger.info(evt.get())
match.push_event(evt)
emit('new_event', evt.get_json(), room=accountant.get_cpanel())
emit('stop_timer', {}, room=message['match'])
app.logger.info("SENT STOP TIMER EVENT")
except:
app.logger.info("ERROR EN REPORT ILLEGAL")
traceback.print_exc()
def get(self, user_id):
"""
Get a list of friend request
"""
request = Request.objects(user=user_id).only('requests_list').first()
if request is None:
return {}
return requests_list_serialize(request.requests_list)
def generate(self):
logging.debug(
f'{self.__new_request_time} : {self.__id + 1} generates new request'
)
request = Request(self.__new_request_time, self.__id)
self.__new_request_time += -1 / self.__lmb * math.log(
random.uniform(0, 1), math.e)
self.__generated += 1
logging.debug(f'new request at {self.__new_request_time}')
return request
def test_add_request_to_time_frame_with_incorrect_volunteer_id_at_request(
self):
session_id = 'someId'
volunteer_id = str(ObjectId())
other_volunteer_id = str(ObjectId())
volunteer = Volunteer('login', 'pw', 'first', 'last', volunteer_id)
self.volunteer_handler.active_user_sessions[session_id] = volunteer
time_frame = TimeFrame(volunteer_id,
datetime.fromisoformat('2020-10-25 12:00:00'),
datetime.fromisoformat('2020-10-25 14:00:00'),
[])
time_frame.id = self.dao.store_one(time_frame.to_db_object())
request = Request(requester=str(ObjectId()),
status=RequestStatus.IN_PROGRESS,
items=[],
volunteer=other_volunteer_id)
request.id = self.requests_dao.store_one(request.to_db_object())
with self.assertRaises(UnauthorizedAccessError):
self.time_frame_handler.add_request_to_time_frame(
time_frame.id, request.id, session_id)
def delete(self, user_id):
args = friendsParser.parse_args()
profile_id = args['profile_id']
if profile_id is None:
abort(400)
success = Request.objects(user=user_id).only('requests_list').update_one(pull__requests_list=profile_id)
if success is 0:
abort(400)
return {'status': 'success', 'message': 'The user has been delete from your friends requests list'}
def test_submit_request_without_address_correctly(self):
session_id = 'sessionId'
requester_id = '5f81ae776db502d353a84fdf'
address = self.address_handler(self.locator.valid_street_1,
self.locator.valid_zip_1,
self.locator.valid_country_1)
requester = Requester('login', 'pw', 'first', 'last', requester_id,
address)
self.requester_handler.active_user_sessions[session_id] = requester
request = Request(requester=requester_id,
status=RequestStatus.CREATED,
items=[],
volunteer=None)
request_id = self.requests_dao.store_one(request.to_db_object())
self.request_handler.submit_request(request_id, session_id)
request = self.request_handler.from_db_object(
self.requests_dao.get_all()[0])
self.assertEqual(request.status, RequestStatus.SUBMITTED)
self.assertEqual(request.delivery_address, address)
self.assertIsNot(request.submission_date, None)
self.assertTrue(type(request.submission_date) == datetime)
def delete(self, user_id):
args = teamParser.parse_args()
profileID = args['profileID']
request = Request.objects(user=user_id, type='join').only('requests_list').first()
if request is None:
raise InvalidUsage('Request does not exist')
success = request.update(pull__requests_list=profileID)
if success is 0:
raise InvalidUsage('Request does not exist')
return {'status' : 'success'}
def request(event, context):
logger.info(f"event: {event}")
email = APIGatewayEvent(event).email
# Add request to DynamoDB
requestDAO = RequestDAO()
data = json.loads(event["body"])
requestDAO.send_request(
Request(str(uuid()), data["requestType"], email, data["date"],
data["data"], data["status"]))
body = {"message": "Request received"}
response = {"statusCode": 200, "body": json.dumps(body)}
return response
def delete(self, user_id):
"""
Decline the friend request
Reomve the request from friend request
"""
args = friendsParser.parse_args()
profile_id = args['profile_id']
if profile_id is None:
abort(400)
success = Request.objects(user=user_id).only(
'requests_list').update_one(pull__requests_list=profile_id)
if success is 0:
abort(400)
return {'status': 'success', 'message':
'The user has been delete from your friends requests list'}
def test_get_requesters_own_requests_correctly(self):
session_id = 'sessionId'
requester_id = '5f7c2d96e48e242b81178822'
other_requester_id = '5f81ae36fa3b02a743177500'
requester = Requester('login', 'pw', 'first', 'last', requester_id)
self.requester_handler.active_user_sessions[session_id] = requester
item = Item('item', 42.42, 'category', '5f7c28c6e979c6a33a1f3f79',
ProductDetails('', {}), Image('', ''))
item_id = self.items_dao.store_one(item.to_db_object())
item.id = item_id
request_1 = Request(requester=requester_id,
status=RequestStatus.CREATED,
items=[],
volunteer=None)
request_2 = Request(requester=requester_id,
status=RequestStatus.IN_PROGRESS,
items=[(item, 3)],
volunteer='5f81ae776db502d353a84fdf',
submission_date=datetime.now())
request_3 = Request(requester=other_requester_id,
status=RequestStatus.PAID,
items=[(item, 1)],
volunteer='5f81ae776db502d353a84fdf',
submission_date=datetime.now())
request_1_id = self.requests_dao.store_one(request_1.to_db_object())
request_2_id = self.requests_dao.store_one(request_2.to_db_object())
request_3_id = self.requests_dao.store_one(request_3.to_db_object())
requests = self.request_handler.get_requesters_own_requests(session_id)
self.assertEqual(len(requests), 2)
self.assertIn(request_1_id, [request['id'] for request in requests])
self.assertIn(request_2_id, [request['id'] for request in requests])
self.assertEqual(
len([r for r in requests if r['id'] == request_2_id][0]['items']),
1)
self.assertEqual([r for r in requests if r['id'] == request_2_id
][0]['items'][0]['item']['id'], item_id)
def post(self, user_id):
args = teamParser.parse_args()
profile = Profile.objects(user=user_id).first()
if profile.LOLTeam is not None:
raise InvalidUsage('Already joined a team')
teamName = args['teamName']
team = LOLTeam.objects(teamName=teamName).first()
if team is None:
raise InvalidUsage('Team not found',404)
captain = team.captain
request = Request.objects(user=captain.user,type='join').only('requests_list').first()
if request is None:
request = Request(user=captain.user,type='join')
request.save()
request.update(add_to_set__requests_list=profile)
return {'status' : 'success'}
def post(self, user_id):
args = teamParser.parse_args()
profileID = args['profileID']
request = Request.objects(user=user_id, type='join').only('requests_list').first()
if request is None:
raise InvalidUsage('Request does not exist')
captain = Profile.objects(user=user_id).first()
team = captain.LOLTeam
if team is None:
raise InvalidUsage('Request is illegal')
if team.captain != captain:
raise InvalidUsage('Unauthorized',401)
# query the player u want to invite
profile = Profile.objects(id=profileID).first()
success = request.update(pull__requests_list=profile)
if success is 0:
raise InvalidUsage('Request not found')
if profile is None:
raise InvalidUsage('Member not found',404)
if profile.LOLTeam is not None:
raise InvalidUsage('The user already joined a team')
try:
assert len(team.members) < 6
team.members.append(profile)
except:
raise InvalidUsage('Team is full',403)
profile.LOLTeam = team
team.save()
profile.save()
rongcloudJoinGroup(profile.id,team.id,teamName)
return team_serialize(team)
def post(self, user_id):
args = teamParser.parse_args()
profileID = args['profileID']
teamIntro = args['teamIntro']
profile = Profile.objects(user=user_id).first()
if profileID == profile.id:
raise InvalidUsage('Cannot send request to yourself')
team = profile.LOLTeam
if profileID is None and teamIntro is not None:
if team.captain is not profile:
raise InvalidUsage('Unauthorized',401)
team.teamIntro = teamIntro
team.save()
return {'status' : 'success'}
# avoid illegal operation
if team is None:
abort(400)
if team.captain != profile:
raise InvalidUsage('Unauthorized',401)
# query the player u want to invite
profile = Profile.objects(id=profileID).first()
if profile is None:
raise InvalidUsage('Member not found',404)
try:
assert len(team.members) < 6
except:
raise InvalidUsage('Team is full',403)
request = Request.objects(user=profile.user,type='invite').only('requests_list').first()
if request is None:
request = Request(user=profile.user,type='invite')
request.save()
request.update(add_to_set__requests_list=team.captain)
return {'status' : 'success'}
def test_get_open_requests_correctly(self):
session_id = 'sessionId'
volunteer = Volunteer('login', 'pw', 'first', 'last', 'userId')
self.volunteer_handler.active_user_sessions[session_id] = volunteer
request_1 = Request(requester='5f7c2d96e48e242b81178822',
status=RequestStatus.CREATED,
items=[],
volunteer=None,
submission_date=datetime.now())
request_2 = Request(requester='5f7c2d96e48e242b81178822',
status=RequestStatus.SUBMITTED,
items=[],
volunteer=None,
submission_date=datetime.now())
request_1_id = self.requests_dao.store_one(request_1.to_db_object())
request_2_id = self.requests_dao.store_one(request_2.to_db_object())
requests = self.request_handler.get_open_requests(session_id)
self.assertEqual(len(requests), 1)
self.assertEqual(requests[0]['id'], request_2_id)
def parseInputs():
script, filename = argv
txt = open(filename)
lines = txt.read().split('\n')
first_line = lines[0]
(no_videos, no_endpoints, no_requests, no_caches,
cache_size) = intTuple(first_line)
video_size = intTuple(lines[1])
debug("Video %d" % no_videos)
debug("Videos size : ")
debug(video_size)
videos = []
for i in range(no_videos):
videos.append(Video(i, video_size[i]))
debug(videos)
caches = []
for i in range(no_caches):
caches.append(Cache(i, cache_size, []))
debug(caches)
idx = 2
# loop endpoint
endpoints = []
endpoint_id = 0
while (no_endpoints > 0):
(latency_to_dc, no_caches) = intTuple(lines[idx])
idx = idx + 1
latency_to_caches = dict()
for i in range(no_caches):
(cache_server, latency) = intTuple(lines[idx])
latency_to_caches[cache_server] = latency
idx = idx + 1
en = Endpoint(endpoint_id, latency_to_caches, latency_to_dc)
endpoints.append(en)
endpoint_id = endpoint_id + 1
no_endpoints = no_endpoints - 1
debug(endpoints)
requests = []
while (no_requests > 0):
(video_id, endpoint_id, reqs) = intTuple(lines[idx])
requests.append(Request(video_id, endpoint_id, reqs))
idx = idx + 1
no_requests = no_requests - 1
debug(requests)
idx = 2
return (caches, endpoints, requests, videos)
