def test_reserve_experiment(self):
db_sess_id = DatabaseSession.ValidDatabaseSessionId('student2', "student")
sess_id, _ = self.ups.do_reserve_session(db_sess_id)
exp_id = ExperimentId('this does not experiment','this neither')
self.assertRaises(
coreExc.UnknownExperimentIdError,
self.ups.reserve_experiment,
sess_id, exp_id, "{}", "{}", ClientAddress.ClientAddress("127.0.0.1")
)
exp_id = ExperimentId('ud-dummy','Dummy experiments')
lab_sess_id = SessionId.SessionId("lab_session_id")
self.lab_mock.reserve_experiment(exp_id, "{}")
self.mocker.result(lab_sess_id)
self.mocker.count(0, 1)
self.lab_mock.resolve_experiment_address(lab_sess_id)
self.mocker.result(CoordAddress.CoordAddress.translate_address('foo:bar@machine'))
self.mocker.count(0, 1)
self.mocker.replay()
reservation = self.ups.reserve_experiment(
sess_id, exp_id, "{}", "{}",
ClientAddress.ClientAddress("127.0.0.1")
)
self.assertTrue( isinstance(reservation,Reservation.Reservation))
self.ups.logout(sess_id)
def test_reserve_experiment_waiting_confirmation(self):
status = self.processor.reserve_experiment(
ExperimentId('ud-dummy', 'Dummy experiments'), "{}", "{}",
ClientAddress.ClientAddress("127.0.0.1"), 'uuid')
self.assertTrue(
isinstance(status,
WebLabSchedulingStatus.WaitingConfirmationQueueStatus))
def process_Submit(self):
lab_server_id, experiment_specification, _, _ = self.serializer.parse_submit_request(
self.payload)
request = {'operation': 'submit', 'payload': experiment_specification}
reservation_status = self.server.reserve_experiment(
self.sess_id, ExperimentId(lab_server_id, 'iLab experiments'),
json.dumps(request), '{}', ClientAddress.ClientAddress(''))
self.other_cookies = [
'weblab_reservation_id=%s; path=/' %
reservation_status.reservation_id.id
]
return """<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<soap:Body>
<SubmitResponse xmlns="http://ilab.mit.edu">
<SubmitResult>
<vReport>
<accepted>true</accepted>
<errorMessage />
<estRuntime>8</estRuntime>
</vReport>
<experimentID>61</experimentID>
<minTimeToLive>0</minTimeToLive>
<wait>
<effectiveQueueLength>%s</effectiveQueueLength>
<estWait>5</estWait>
</wait>
</SubmitResult>
</SubmitResponse>
</soap:Body>
</soap:Envelope>""" % reservation_status.position
def test_get_reservation_info(self):
db_sess_id = DatabaseSession.ValidDatabaseSessionId('student2', "student")
sess_id, _ = self.ups.do_reserve_session(db_sess_id)
exp_id = ExperimentId('ud-dummy','Dummy experiments')
lab_sess_id = SessionId.SessionId("lab_session_id")
self.lab_mock.reserve_experiment(exp_id, "{}")
self.mocker.result(lab_sess_id)
self.mocker.count(0, 1)
self.lab_mock.resolve_experiment_address(lab_sess_id)
self.mocker.result(CoordAddress.CoordAddress.translate_address('foo:bar@machine'))
self.mocker.count(0, 1)
self.mocker.replay()
reservation = self.ups.reserve_experiment(
sess_id, exp_id, "{}", "{}",
ClientAddress.ClientAddress("127.0.0.1")
)
reservation_info = self.ups.get_reservation_info(reservation.reservation_id)
self.assertEquals('ud-dummy', reservation_info.exp_name)
self.assertEquals('Dummy experiments', reservation_info.cat_name)
self.ups.logout(sess_id)
def test_reserve_experiment_not_found(self):
self.coordinator._clean()
self.assertRaises(coreExc.NoAvailableExperimentFoundError,
self.processor.reserve_experiment,
ExperimentId('ud-dummy',
'Dummy experiments'), "{}", "{}",
ClientAddress.ClientAddress("127.0.0.1"), 'uuid')
def test_reserve_experiment_repeated_uuid(self):
uuid = self.cfg_manager.get_value(
WEBLAB_CORE_SERVER_UNIVERSAL_IDENTIFIER)
status = self.processor.reserve_experiment(
ExperimentId('ud-dummy', 'Dummy experiments'), "{}",
'{ "%s" : [["%s","server x"]]}' %
(UserProcessor.SERVER_UUIDS, uuid),
ClientAddress.ClientAddress("127.0.0.1"), uuid)
self.assertEquals('replicated', status)
def login_based_on_client_address(self, username, client_address):
""" login_based_on_client_address(username, client_address) -> SessionID
raises LoginError, InvalidCredentialsError
"""
current_client_address = self._get_client_address()
addresses_calling_this_method = self._cfg_manager.get_value(ADDRESSES_CALLING_LOGIN_BASED_ON_CLIENT_ADDRESS, DEFAULT_ADDRESSES_CALLING_LOGIN_BASED_ON_CLIENT_ADDRESS)
if current_client_address in addresses_calling_this_method:
return self._login_impl( username, ClientAddress.ClientAddress(client_address) )
else:
return self._raise_exception(
LFCodes.CLIENT_INVALID_CREDENTIALS_EXCEPTION_CODE,
"You can't login from IP address: %s" % current_client_address
)
def process_GetLabConfiguration(self):
lab_server_id = self.serializer.parse_get_lab_configuration_request(
self.payload)
request = {
'operation': 'get_lab_configuration',
}
# TODO: client address
reservation_status = self.server.reserve_experiment(
self.sess_id, ExperimentId(lab_server_id, 'iLab experiments'),
json.dumps(request), '{}', ClientAddress.ClientAddress(''))
lab_configuration = reservation_status.initial_data
return self.serializer.generate_lab_configuration_response(
lab_configuration)
def reserve_experiment(self, session_id, experiment_id,
client_initial_data, consumer_data):
""" reserve_experiment(session_id, experiment_id, client_initial_data) -> Reservation
raises SessionNotFoundError, NoAvailableExperimentFoundError
"""
current_client_address = ClientAddress.ClientAddress(
self._get_client_address())
sess_id = self._parse_session_id(session_id)
exp_id = self._parse_experiment_id(experiment_id)
reservation_status = self._server.reserve_experiment(
sess_id, exp_id, client_initial_data, consumer_data,
current_client_address)
return reservation_status
def _reserve_experiment(self):
db_sess_id = DatabaseSession.ValidDatabaseSessionId('student1', "student")
sess_id, _ = self.ups.do_reserve_session(db_sess_id)
exp_id = ExperimentId('ud-dummy','Dummy experiments')
lab_sess_id = SessionId.SessionId("lab_session_id")
self.lab_mock.reserve_experiment(exp_id, "{}")
self.mocker.result(lab_sess_id)
self.mocker.count(0, 1)
self.lab_mock.resolve_experiment_address(lab_sess_id)
self.mocker.result(CoordAddress.CoordAddress.translate_address('foo:bar@machine'))
self.mocker.count(0, 1)
self.mocker.replay()
reservation = self.ups.reserve_experiment(
sess_id, exp_id, "{}", "{}",
ClientAddress.ClientAddress("127.0.0.1"))
return reservation.reservation_id
def create_reservation_processor(self, faking_response=False):
if faking_response:
self._fake_simple_lab_response()
status = self.user_processor.reserve_experiment(
ExperimentId('ud-dummy', 'Dummy experiments'), "{}", "{}",
ClientAddress.ClientAddress("127.0.0.1"), 'uuid')
self.reservation_processor = ReservationProcessor(
self.cfg_manager,
SessionId.SessionId(status.reservation_id.split(';')[0]), {
'session_polling':
(time.time(), ReservationProcessor.EXPIRATION_TIME_NOT_SET),
'latest_timestamp':
0,
'experiment_id':
ExperimentId('ud-dummy', 'Dummy experiments'),
'creator_session_id':
'',
'reservation_id':
SessionId.SessionId(status.reservation_id.split(';')[0]),
}, self.coordinator, self.locator, self.commands_store)
def run(self):
experiment_id_str = self.get_argument(EXPERIMENT_ID)
if experiment_id_str is None:
return "%s argument is missing" % EXPERIMENT_ID
session_id_str = self.get_argument(SESSION_ID)
if session_id_str is None:
return "%s argument is missing" % EXPERIMENT_ID
experiment_id = ExperimentId.parse(experiment_id_str)
session_id = SessionId(session_id_str)
address = RemoteFacadeContext.get_context().get_ip_address()
client_address = ClientAddress.ClientAddress(address)
try:
reservation_id = self.server.reserve_experiment(
session_id, experiment_id, "{}", "{}", client_address)
except Exception:
return HTML_ERROR_TEMPLATE
new_location = "../../client/federated.html#reservation_id=%s" % reservation_id.reservation_id.id
self.set_status(302)
self.add_other_header('Location', new_location)
return """<html><body><a href="%s">Click here</a></body></html>""" % new_location
def _single_async_use(self, logout = True):
self.fake_impact1.clear()
self.fake_impact2.clear()
self.fake_serial_port1.clear()
self.fake_serial_port2.clear()
session_id = self.real_login.login('student1','password')
user_information = self.real_ups.get_user_information(session_id)
self.assertEquals(
'student1',
user_information.login
)
self.assertEquals(
'Name of student 1',
user_information.full_name
)
self.assertEquals(
'*****@*****.**',
user_information.email
)
experiments = self.real_ups.list_experiments(session_id)
self.assertEquals( 5, len(experiments))
fpga_experiments = [ exp.experiment for exp in experiments if exp.experiment.name == 'ud-fpga' ]
self.assertEquals(
len(fpga_experiments),
1
)
# reserve it
status = self.real_ups.reserve_experiment(
session_id,
fpga_experiments[0].to_experiment_id(),
"{}", "{}",
ClientAddress.ClientAddress("127.0.0.1")
)
reservation_id = status.reservation_id
# wait until it is reserved
short_time = 0.1
# Time extended from 9.0 to 15.0 because at times the test failed, possibly for that reason.
times = 15.0 / short_time
while times > 0:
time.sleep(short_time)
new_status = self.real_ups.get_reservation_status(reservation_id)
if not isinstance(new_status, Reservation.WaitingConfirmationReservation) and not isinstance(new_status, Reservation.WaitingReservation):
break
times -= 1
reservation = self.real_ups.get_reservation_status(
reservation_id
)
self.assertTrue(
isinstance(
reservation,
Reservation.ConfirmedReservation
),
"Reservation %s is not Confirmed, as expected by this time" % reservation
)
# send the program again, but asynchronously. Though this should work, it is not really very customary
# to send_file more than once in the same session. In fact, it is a feature which might get removed in
# the future. When/if that happens, this will need to be modified.
CONTENT = "content of the program FPGA"
reqid = self.real_ups.send_async_file(reservation_id, ExperimentUtil.serialize(CONTENT), 'program')
# Wait until send_async_file query is actually finished.
#self._get_async_response(session_id, reqid)
self._wait_async_done(reservation_id, (reqid,))
# We need to wait for the programming to finish, while at the same
# time making sure that the tests don't dead-lock.
start_time = time.time()
response = "STATE=not_ready"
while response in ("STATE=not_ready", "STATE=programming") and time.time() - start_time < XILINX_TIMEOUT:
reqid = self.real_ups.send_async_command(reservation_id, Command.Command("STATE"))
respcmd = self._get_async_response(reservation_id, reqid)
response = respcmd.get_command_string()
time.sleep(0.2)
# Check that the current state is "Ready"
self.assertEquals("STATE=ready", response)
reqid = self.real_ups.send_async_command(reservation_id, Command.Command("ChangeSwitch on 0"))
self._wait_async_done(reservation_id, (reqid,))
reqid = self.real_ups.send_async_command(reservation_id, Command.Command("ClockActivation on 250"))
self._wait_async_done(reservation_id, (reqid,))
# Checking the commands sent
# Note that the number of paths is 2 now that we send a file twice (sync and async).
self.assertEquals(
1,
len(self.fake_impact1._paths)
)
self.assertEquals(
0,
len(self.fake_impact2._paths)
)
self.assertEquals(
CONTENT,
self.fake_impact1._paths[0]
)
initial_open = 1
initial_send = 1
initial_close = 1
initial_total = initial_open + initial_send + initial_close
# ChangeSwitch on 0
self.assertEquals(
(0 + initial_total,1),
self.fake_serial_port1.dict['open'][0 + initial_open]
)
self.assertEquals(
(1 + initial_total,1),
self.fake_serial_port1.dict['send'][0 + initial_send]
)
self.assertEquals(
(2 + initial_total,None),
self.fake_serial_port1.dict['close'][0 + initial_close]
)
# ClockActivation on 250
self.assertEquals(
(3 + initial_total,1),
self.fake_serial_port1.dict['open'][1 + initial_open]
)
self.assertEquals(
(4 + initial_total,32),
self.fake_serial_port1.dict['send'][1 + initial_send]
)
self.assertEquals(
(5 + initial_total,None),
self.fake_serial_port1.dict['close'][1 + initial_close]
)
if logout:
self.real_ups.logout(session_id)
def test_kickout_from_coordinator(self):
category = "Dummy experiments"
experiment = "ud-dummy"
db_sess_id = DatabaseSession.ValidDatabaseSessionId('student2', "student")
sess_id, _ = self.ups.do_reserve_session(db_sess_id)
status = self.ups.reserve_experiment(sess_id, ExperimentId( experiment, category ), "{}", "{}", ClientAddress.ClientAddress( "127.0.0.1" ))
reservation_session_id = status.reservation_id
status = self.ups.get_reservation_status(reservation_session_id)
self.assertNotEquals( None, status )
reservation_id = methods.get_reservation_id.call(sess_id.id)
methods.kickout_from_coordinator.call(reservation_id)
self.assertRaises( core_exc.NoCurrentReservationError, self.ups.get_reservation_status, reservation_session_id )
def test_get_reservation_id_one_user(self):
category = "Dummy experiments"
experiment = "ud-dummy"
db_sess_id = DatabaseSession.ValidDatabaseSessionId('student2', "student")
sess_id, _ = self.ups.do_reserve_session(db_sess_id)
self.ups.reserve_experiment(sess_id, ExperimentId( experiment, category ), "{}", "{}", ClientAddress.ClientAddress( "127.0.0.1" ))
reservation_id = methods.get_reservation_id.call(sess_id.id)
self.assertNotEquals(None, reservation_id)
def test_get_experiment_ups_session_ids(self):
category = "Dummy experiments"
experiment = "ud-dummy"
db_sess_id = DatabaseSession.ValidDatabaseSessionId('student2', "student")
sess_id, _ = self.ups.do_reserve_session(db_sess_id)
#
# It returns only the sessions_ids of the experiments
#
result = methods.get_experiment_ups_session_ids.call(category, experiment)
self.assertEquals( [], result )
status = self.ups.reserve_experiment( sess_id, ExperimentId( experiment, category ), "{}", "{}", ClientAddress.ClientAddress( "127.0.0.1" ))
result = methods.get_experiment_ups_session_ids.call(category, experiment)
self.assertEquals( 1, len(result) )
session_id, login, reservation_id = result[0]
self.assertEquals( status.reservation_id.id.split(';')[0], session_id )
self.assertEquals( "student2", login )
def test_reserve_unknown_experiment_name(self):
self.assertRaises(coreExc.UnknownExperimentIdError,
self.processor.reserve_experiment,
ExperimentId('<invalid>',
'Dummy experiments'), "{}", "{}",
ClientAddress.ClientAddress("127.0.0.1"), 'uuid')
def test_single_uses_timeout(self):
self.fake_impact1.clear()
self.fake_impact2.clear()
self.fake_serial_port1.clear()
self.fake_serial_port2.clear()
# 6 users get into the system
session_id1 = self.real_login.login('student1', 'password')
session_id2 = self.real_login.login('student2', 'password')
session_id3 = self.real_login.login('student3', 'password')
session_id4 = self.real_login.login('student4', 'password')
session_id5 = self.real_login.login('student5', 'password')
session_id6 = self.real_login.login('student6', 'password')
# they all have access to the ud-fpga experiment
experiments1 = self.real_ups.list_experiments(session_id1)
fpga_experiments1 = [
exp.experiment for exp in experiments1
if exp.experiment.name == 'ud-fpga'
]
self.assertEquals(len(fpga_experiments1), 1)
experiments2 = self.real_ups.list_experiments(session_id2)
fpga_experiments2 = [
exp.experiment for exp in experiments2
if exp.experiment.name == 'ud-fpga'
]
self.assertEquals(len(fpga_experiments2), 1)
experiments3 = self.real_ups.list_experiments(session_id3)
fpga_experiments3 = [
exp.experiment for exp in experiments3
if exp.experiment.name == 'ud-fpga'
]
self.assertEquals(len(fpga_experiments3), 1)
experiments4 = self.real_ups.list_experiments(session_id4)
fpga_experiments4 = [
exp.experiment for exp in experiments4
if exp.experiment.name == 'ud-fpga'
]
self.assertEquals(len(fpga_experiments4), 1)
experiments5 = self.real_ups.list_experiments(session_id5)
fpga_experiments5 = [
exp.experiment for exp in experiments5
if exp.experiment.name == 'ud-fpga'
]
self.assertEquals(len(fpga_experiments5), 1)
experiments6 = self.real_ups.list_experiments(session_id6)
fpga_experiments6 = [
exp.experiment for exp in experiments6
if exp.experiment.name == 'ud-fpga'
]
self.assertEquals(len(fpga_experiments6), 1)
# 3 users try to reserve the experiment
status1 = self.real_ups.reserve_experiment(
session_id1, fpga_experiments1[0].to_experiment_id(), "{}", "{}",
ClientAddress.ClientAddress("127.0.0.1"))
reservation_id1 = status1.reservation_id
status2 = self.real_ups.reserve_experiment(
session_id2, fpga_experiments2[0].to_experiment_id(), "{}", "{}",
ClientAddress.ClientAddress("127.0.0.1"))
reservation_id2 = status2.reservation_id
status3 = self.real_ups.reserve_experiment(
session_id3, fpga_experiments3[0].to_experiment_id(), "{}", "{}",
ClientAddress.ClientAddress("127.0.0.1"))
reservation_id3 = status3.reservation_id
# wait until it is reserved
short_time = 0.1
times = 10.0 / short_time
while times > 0:
time.sleep(short_time)
new_status = self.real_ups.get_reservation_status(reservation_id1)
if not isinstance(new_status,
Reservation.WaitingConfirmationReservation):
break
times -= 1
# first user got the device. The other two are in WaitingReservation
reservation1 = self.real_ups.get_reservation_status(reservation_id1)
self.assertTrue(
isinstance(reservation1, Reservation.ConfirmedReservation))
reservation2 = self.real_ups.get_reservation_status(reservation_id2)
self.assertTrue(
isinstance(reservation2, Reservation.WaitingReservation))
self.assertEquals(0, reservation2.position)
reservation3 = self.real_ups.get_reservation_status(reservation_id3)
self.assertTrue(
isinstance(reservation3, Reservation.WaitingReservation))
self.assertEquals(1, reservation3.position)
# Another user tries to reserve the experiment. He goes to the WaitingReservation, position 2
status4 = self.real_ups.reserve_experiment(
session_id4, fpga_experiments4[0].to_experiment_id(), "{}", "{}",
ClientAddress.ClientAddress("127.0.0.1"))
reservation_id4 = status4.reservation_id
reservation4 = self.real_ups.get_reservation_status(reservation_id4)
self.assertTrue(
isinstance(reservation4, Reservation.WaitingReservation))
self.assertEquals(2, reservation4.position)
# The state of other users does not change
reservation1 = self.real_ups.get_reservation_status(reservation_id1)
self.assertTrue(
isinstance(reservation1, Reservation.ConfirmedReservation))
reservation2 = self.real_ups.get_reservation_status(reservation_id2)
self.assertTrue(
isinstance(reservation2, Reservation.WaitingReservation))
self.assertEquals(0, reservation2.position)
reservation3 = self.real_ups.get_reservation_status(reservation_id3)
self.assertTrue(
isinstance(reservation3, Reservation.WaitingReservation))
self.assertEquals(1, reservation3.position)
# The user number 2 frees the experiment
self.real_ups.finished_experiment(reservation_id2)
# Whenever he tries to do poll or send_command, he receives an exception
try:
self.real_ups.poll(reservation_id2)
self.real_ups.poll(reservation_id2)
self.real_ups.poll(reservation_id2)
except core_exc.NoCurrentReservationError:
pass # All right :-)
# send a program
CONTENT = "content of the program FPGA"
self.real_ups.send_file(reservation_id1,
ExperimentUtil.serialize(CONTENT), 'program')
# We need to wait for the programming to finish.
start_time = time.time()
response = "STATE=not_ready"
while response in ("STATE=not_ready", "STATE=programming"
) and time.time() - start_time < XILINX_TIMEOUT:
respcmd = self.real_ups.send_command(reservation_id1,
Command.Command("STATE"))
response = respcmd.get_command_string()
time.sleep(0.2)
# Check that the current state is "Ready"
self.assertEquals("STATE=ready", response)
self.real_ups.send_command(reservation_id1,
Command.Command("ChangeSwitch on 0"))
self.real_ups.send_command(reservation_id1,
Command.Command("ClockActivation on 250"))
# end session
self.real_ups.logout(session_id1)
# Checking the commands sent
self.assertEquals(1, len(self.fake_impact1._paths))
self.assertEquals(0, len(self.fake_impact2._paths))
self.assertEquals(CONTENT, self.fake_impact1._paths[0])
initial_open = 1
initial_send = 1
initial_close = 1
initial_total = initial_open + initial_send + initial_close
# ChangeSwitch on 0
self.assertEquals(
(0 + initial_total, 1),
self.fake_serial_port1.dict['open'][0 + initial_open])
self.assertEquals(
(1 + initial_total, 1),
self.fake_serial_port1.dict['send'][0 + initial_send])
self.assertEquals(
(2 + initial_total, None),
self.fake_serial_port1.dict['close'][0 + initial_close])
# ClockActivation on 250
self.assertEquals(
(3 + initial_total, 1),
self.fake_serial_port1.dict['open'][1 + initial_open])
self.assertEquals(
(4 + initial_total, 32),
self.fake_serial_port1.dict['send'][1 + initial_send])
self.assertEquals(
(5 + initial_total, None),
self.fake_serial_port1.dict['close'][1 + initial_close])
def test_two_multiple_uses_of_different_devices(self):
user1_session_id = self.real_login.login('student1','password')
user1_experiments = self.real_ups.list_experiments(user1_session_id)
self.assertEquals(
5,
len(user1_experiments)
)
fpga_experiments = [ exp.experiment for exp in user1_experiments if exp.experiment.name == 'ud-fpga' ]
self.assertEquals(
len(fpga_experiments),
1
)
# reserve it
status = self.real_ups.reserve_experiment(
user1_session_id,
fpga_experiments[0].to_experiment_id(),
"{}", "{}",
ClientAddress.ClientAddress("127.0.0.1")
)
user1_reservation_id = status.reservation_id
user2_session_id = self.real_login.login('student2','password')
user2_experiments = self.real_ups.list_experiments(user2_session_id)
self.assertEquals(
7,
len(user2_experiments)
)
pld_experiments = [ exp.experiment for exp in user2_experiments if exp.experiment.name == 'ud-pld' ]
self.assertEquals(
len(pld_experiments),
1
)
# reserve it
status = self.real_ups.reserve_experiment(
user2_session_id,
pld_experiments[0].to_experiment_id(),
"{}", "{}",
ClientAddress.ClientAddress("127.0.0.1")
)
user2_reservation_id = status.reservation_id
short_time = 0.1
times = 9.0 / short_time
while times > 0:
time.sleep(short_time)
new_status1 = self.real_ups.get_reservation_status(user1_reservation_id)
new_status2 = self.real_ups.get_reservation_status(user2_reservation_id)
if not isinstance(new_status1, Reservation.WaitingConfirmationReservation):
if not isinstance(new_status2, Reservation.WaitingConfirmationReservation):
break
times -= 1
self.assertTrue(
isinstance(
self.real_ups.get_reservation_status(
user1_reservation_id
),
Reservation.ConfirmedReservation
)
)
self.assertTrue(
isinstance(
self.real_ups.get_reservation_status(
user2_reservation_id
),
Reservation.ConfirmedReservation
)
)
# send a program
CONTENT1 = "content of the program FPGA"
self.real_ups.send_file(user1_reservation_id, ExperimentUtil.serialize(CONTENT1), 'program')
# We need to wait for the programming to finish.
start_time = time.time()
response = "STATE=not_ready"
while response in ("STATE=not_ready", "STATE=programming") and time.time() - start_time < XILINX_TIMEOUT:
respcmd = self.real_ups.send_command(user1_reservation_id, Command.Command("STATE"))
response = respcmd.get_command_string()
time.sleep(0.2)
# Check that the current state is "Ready"
self.assertEquals("STATE=ready", response)
self.real_ups.send_command(user1_reservation_id, Command.Command("ChangeSwitch off 1"))
self.real_ups.send_command(user1_reservation_id, Command.Command("ClockActivation on 250"))
CONTENT2 = "content of the program PLD"
self.real_ups.send_file(user2_reservation_id, ExperimentUtil.serialize(CONTENT2), 'program')
# We need to wait for the programming to finish.
start_time = time.time()
response = "STATE=not_ready"
while response in ("STATE=not_ready", "STATE=programming") and time.time() - start_time < XILINX_TIMEOUT:
respcmd = self.real_ups.send_command(user1_reservation_id, Command.Command("STATE"))
response = respcmd.get_command_string()
time.sleep(0.2)
# Check that the current state is "Ready"
self.assertEquals("STATE=ready", response)
self.real_ups.send_command(user2_reservation_id, Command.Command("ChangeSwitch on 0"))
self.real_ups.send_command(user2_reservation_id, Command.Command("ClockActivation on 250"))
# end session
self.real_ups.logout(user1_session_id)
self.real_ups.logout(user2_session_id)
# Checking the commands sent
self.assertEquals(
1,
len(self.fake_impact1._paths)
)
self.assertEquals(
1,
len(self.fake_impact2._paths)
)
self.assertEquals(
CONTENT1,
self.fake_impact1._paths[0]
)
self.assertEquals(
CONTENT2,
self.fake_impact2._paths[0]
)
initial_open = 1
initial_send = 1
initial_close = 1
initial_total = initial_open + initial_send + initial_close
# ChangeSwitch off 1
self.assertEquals(
(0 + initial_total,1),
self.fake_serial_port1.dict['open'][0 + initial_open]
)
self.assertEquals(
(1 + initial_total,4),
self.fake_serial_port1.dict['send'][0 + initial_send]
)
self.assertEquals(
(2 + initial_total,None),
self.fake_serial_port1.dict['close'][0 + initial_close]
)
self.assertEquals(
(0 + initial_total,1),
self.fake_serial_port2.dict['open'][0 + initial_open]
)
self.assertEquals(
(1 + initial_total,1),
self.fake_serial_port2.dict['send'][0 + initial_send]
)
self.assertEquals(
(2 + initial_total,None),
self.fake_serial_port2.dict['close'][0 + initial_close]
)
# ClockActivation on 250
self.assertEquals(
(3 + initial_total,1),
self.fake_serial_port1.dict['open'][1 + initial_open]
)
self.assertEquals(
(4 + initial_total,32),
self.fake_serial_port1.dict['send'][1 + initial_send]
)
self.assertEquals(
(5 + initial_total,None),
self.fake_serial_port1.dict['close'][1 + initial_close]
)
self.assertEquals(
(3 + initial_total,1),
self.fake_serial_port2.dict['open'][1 + initial_open]
)
self.assertEquals(
(4 + initial_total,32),
self.fake_serial_port2.dict['send'][1 + initial_send]
)
self.assertEquals(
(5 + initial_total,None),
self.fake_serial_port2.dict['close'][1 + initial_close]
)
def _single_sync_use(self, logout = True):
self.fake_impact1.clear()
self.fake_impact2.clear()
self.fake_serial_port1.clear()
self.fake_serial_port2.clear()
session_id = self.real_login.login('student1','password')
user_information = self.real_ups.get_user_information(session_id)
self.assertEquals(
'student1',
user_information.login
)
self.assertEquals(
'Name of student 1',
user_information.full_name
)
self.assertEquals(
'*****@*****.**',
user_information.email
)
experiments = self.real_ups.list_experiments(session_id)
self.assertEquals( 5, len(experiments))
fpga_experiments = [ exp.experiment for exp in experiments if exp.experiment.name == 'ud-fpga' ]
self.assertEquals(
len(fpga_experiments),
1
)
# reserve it
status = self.real_ups.reserve_experiment(
session_id,
fpga_experiments[0].to_experiment_id(),
"{}", "{}",
ClientAddress.ClientAddress("127.0.0.1")
)
reservation_id = status.reservation_id
# wait until it is reserved
short_time = 0.1
times = 13.0 / short_time
while times > 0:
new_status = self.real_ups.get_reservation_status(reservation_id)
if not isinstance(new_status, Reservation.WaitingConfirmationReservation) and not isinstance(new_status, Reservation.WaitingReservation):
break
times -= 1
time.sleep(short_time)
reservation = self.real_ups.get_reservation_status(
reservation_id
)
self.assertTrue(
isinstance(
reservation,
Reservation.ConfirmedReservation
),
"Reservation %s is not Confirmed, as expected by this time" % reservation
)
# send a program synchronously (the "traditional" way)
CONTENT = "content of the program FPGA"
self.real_ups.send_file(reservation_id, ExperimentUtil.serialize(CONTENT), 'program')
# We need to wait for the programming to finish, while at the same
# time making sure that the tests don't dead-lock.
start_time = time.time()
response = "STATE=not_ready"
while response in ("STATE=not_ready", "STATE=programming") and time.time() - start_time < XILINX_TIMEOUT:
respcmd = self.real_ups.send_command(reservation_id, Command.Command("STATE"))
response = respcmd.get_command_string()
time.sleep(0.2)
# Check that the current state is "Ready"
self.assertEquals("STATE=ready", response)
# We need to wait for the programming to finish, while at the same
# time making sure that the tests don't dead-lock.
start_time = time.time()
response = "STATE=not_ready"
while response in ("STATE=not_ready", "STATE=programming") and time.time() - start_time < XILINX_TIMEOUT:
respcmd = self.real_ups.send_command(reservation_id, Command.Command("STATE"))
response = respcmd.get_command_string()
time.sleep(0.2)
# Check that the current state is "Ready"
self.assertEquals("STATE=ready", response)
self.real_ups.send_command(reservation_id, Command.Command("ChangeSwitch on 0"))
self.real_ups.send_command(reservation_id, Command.Command("ClockActivation on 250"))
# Checking the commands sent
# Note that the number of paths is 2 now that we send a file twice (sync and async).
self.assertEquals(
1,
len(self.fake_impact1._paths)
)
self.assertEquals(
0,
len(self.fake_impact2._paths)
)
self.assertEquals(
CONTENT,
self.fake_impact1._paths[0]
)
initial_open = 1
initial_send = 1
initial_close = 1
initial_total = initial_open + initial_send + initial_close
# ChangeSwitch on 0
self.assertEquals(
(0 + initial_total,1),
self.fake_serial_port1.dict['open'][0 + initial_open]
)
self.assertEquals(
(1 + initial_total,1),
self.fake_serial_port1.dict['send'][0 + initial_send]
)
self.assertEquals(
(2 + initial_total,None),
self.fake_serial_port1.dict['close'][0 + initial_close]
)
# ClockActivation on 250
self.assertEquals(
(3 + initial_total,1),
self.fake_serial_port1.dict['open'][1 + initial_open]
)
self.assertEquals(
(4 + initial_total,32),
self.fake_serial_port1.dict['send'][1 + initial_send]
)
self.assertEquals(
(5 + initial_total,None),
self.fake_serial_port1.dict['close'][1 + initial_close]
)
# end session
# Note: Before async commands were implemented, this was actually done before
# checking the commands sent. If it was that way for a reason, it might be
# necessary to change it in the future.
if logout:
self.real_ups.logout(session_id)