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)