def test_list_experiments(self): # student1 db_sess_id1 = DatabaseSession.ValidDatabaseSessionId('student1', "student") sess_id1, _ = self.ups.do_reserve_session(db_sess_id1) experiments = self.ups.list_experiments(sess_id1) self.assertEquals(5, len(experiments) ) experiment_names = list(( experiment.experiment.name for experiment in experiments )) self.assertTrue( 'ud-dummy' in experiment_names ) self.assertTrue( 'ud-logic' in experiment_names ) self.assertTrue( 'ud-fpga' in experiment_names ) self.assertTrue( 'flashdummy' in experiment_names ) self.assertTrue( 'javadummy' in experiment_names ) self.ups.logout(sess_id1) # student2 db_sess_id2 = DatabaseSession.ValidDatabaseSessionId('student2', "student") sess_id2, _ = self.ups.do_reserve_session(db_sess_id2) experiments = self.ups.list_experiments(sess_id2) self.assertEquals(7, len(experiments) ) experiment_names = list(( experiment.experiment.name for experiment in experiments )) self.assertTrue( 'ud-dummy' in experiment_names ) self.assertTrue( 'ud-fpga' in experiment_names ) self.assertTrue( 'ud-pld' in experiment_names ) self.assertTrue( 'ud-gpib' in experiment_names ) self.assertTrue( 'ud-logic' in experiment_names ) self.assertTrue( 'javadummy' in experiment_names ) self.assertTrue( 'flashdummy' in experiment_names ) self.ups.logout(sess_id2)
def test_get_ups_session_ids_from_username(self): db_sess_id = DatabaseSession.ValidDatabaseSessionId('student2', "student") sess_id1, _ = self.ups.do_reserve_session(db_sess_id) db_sess_id = DatabaseSession.ValidDatabaseSessionId('student2', "student") sess_id2, _ = self.ups.do_reserve_session(db_sess_id) sessions = methods.get_ups_session_ids_from_username.call("student2") self.assertEquals(set([sess_id1, sess_id2]), set(sessions))
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_get_users(self): db_sess_id = DatabaseSession.ValidDatabaseSessionId('student1', 'student') sess_id, _ = self.ups.do_reserve_session(db_sess_id) users = self.ups.get_users(sess_id) self.ups.logout(sess_id) # Make sure that the number of users it returns matches the number of users # that we currently have in the test database. self.assertEquals(len(users), 27) user_logins = list( ( user.login for user in users ) ) # Make sure every single user login we currently have is present for i in range(1,9): self.assertTrue( "student%d" % i in user_logins ) for i in range(1, 4): self.assertTrue( "admin%d" % i in user_logins ) self.assertTrue( "prof%d" % i in user_logins ) self.assertTrue( "studentLDAP%d" % i in user_logins ) self.assertTrue("any" in user_logins) self.assertTrue("studentLDAPwithoutUserAuth" in user_logins) # Check mails user_mails = list( user.email for user in users ) user_mails_set = set(user_mails) self.assertEquals(len(user_mails_set), 1) self.assertTrue( "*****@*****.**" in user_mails_set ) # Check a few login / full name pairs user_logins_names = list( (user.login, user.full_name) for user in users ) for i in range(1, 9): self.assertTrue( ("student%d" % i, "Name of student %d" % i) in user_logins_names ) for i in range(1, 3): self.assertTrue( ("admin%d" % i, "Name of administrator %d" % i) in user_logins_names )
def _test_get_experiment_uses(self, from_date, to_date, group_id, use_experiment_id, start_row, end_row, sort_by): # # Two users: student2, that started before "any" but finished after "any", and "any" then. Both use # the same experiment. # experiment_id = self.ups._db_manager._gateway._insert_user_used_experiment("student2", "ud-fpga", "FPGA experiments", time.time() - 3600, "192.168.1.1", "fpga:process1@scabb", '5', time.time() - 1000) self.ups._db_manager._gateway._insert_user_used_experiment("any", "ud-fpga", "FPGA experiments", time.time() - 1800, "127.0.0.1", "fpga:process1@scabb", '6', time.time() - 1700) if not use_experiment_id: experiment_id = None elif use_experiment_id == 'other': experiment_id += 2 # # student4 uses a different experiment, after both student2 and any # self.ups._db_manager._gateway._insert_user_used_experiment("student4", "ud-dummy", "Dummy experiments", time.time() - 60, "unknown", "fpga:process1@scabb", '7', time.time() - 60) self.ups._db_manager._gateway._insert_ee_used_experiment("ee1", "ud-dummy", "Dummy experiments", time.time() - 60, "unknown", "dummy:process1@plunder", '8', time.time() - 60) db_sess_id = DatabaseSession.ValidDatabaseSessionId('student1', "student") sess_id, _ = self.ups.do_reserve_session(db_sess_id) experiment_uses, experiment_uses_number = self.ups.get_experiment_uses(sess_id, from_date, to_date, group_id, experiment_id, start_row, end_row, sort_by) self.ups.logout(sess_id) return experiment_uses, experiment_uses_number
def setUp(self): self.mocker = mocker.Mocker() self.lab_mock = self.mocker.mock() self.locator = FakeLocator(lab=self.lab_mock) self.db = FakeDatabase() self.cfg_manager = ConfigurationManager.ConfigurationManager() self.cfg_manager.append_module(configuration_module) self.cfg_manager._set_value( COORDINATOR_LABORATORY_SERVERS, { 'server:laboratoryserver@labmachine': { 'inst|ud-dummy|Dummy experiments': 'res_inst@res_type' } }) self.commands_store = TemporalInformationStore.CommandsTemporalInformationStore( ) self.coordinator = coordinator_create(SQLALCHEMY, self.locator, self.cfg_manager) self.coordinator._clean() self.coordinator.add_experiment_instance_id( "server:laboratoryserver@labmachine", ExperimentInstanceId('inst', 'ud-dummy', 'Dummy experiments'), Resource("res_type", "res_inst")) self.user_processor = UserProcessor.UserProcessor( self.locator, { 'db_session_id': DbSession.ValidDatabaseSessionId('my_db_session_id') }, self.cfg_manager, self.coordinator, self.db, self.commands_store)
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_kickout_from_ups(self): db_sess_id = DatabaseSession.ValidDatabaseSessionId('student2', "student") sess_id, _ = self.ups.do_reserve_session(db_sess_id) methods.kickout_from_ups.call(sess_id.id) self.assertRaises( core_exc.SessionNotFoundError, self.ups.get_reservation_status, sess_id)
def test_get_users_without_permission(self): db_sess_id = DatabaseSession.ValidDatabaseSessionId('student2', "student") sess_id, _ = self.ups.do_reserve_session(db_sess_id) users = self.ups.get_users(sess_id) self.ups.logout(sess_id) self.assertEquals(0, len(users) )
def test_get_groups_without_permission(self): db_sess_id = DatabaseSession.ValidDatabaseSessionId('student2', "student") sess_id, _ = self.ups.do_reserve_session(db_sess_id) groups = self.ups.get_groups(sess_id, parent_id=None) self.ups.logout(sess_id) self.assertEquals(0, len(groups) )
def _test_get_groups_with_permission(self, parent_id): db_sess_id = DatabaseSession.ValidDatabaseSessionId('student1', "student") sess_id, _ = self.ups.do_reserve_session(db_sess_id) groups = self.ups.get_groups(sess_id, parent_id) self.ups.logout(sess_id) return groups
def test_reserve_session(self): db_sess_id = DatabaseSession.ValidDatabaseSessionId('student2', "student") sess_id, _ = self.ups.do_reserve_session(db_sess_id) session_manager = self.ups._session_manager sess = session_manager.get_session(sess_id) self.assertEquals(sess['db_session_id'].username, db_sess_id.username) self.ups.logout(sess_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_user_information(self): db_sess_id = DatabaseSession.ValidDatabaseSessionId('student2', "student") sess_id, _ = self.ups.do_reserve_session(db_sess_id) user = self.ups.get_user_information(sess_id) self.assertEquals("student2",user.login) self.assertEquals("Name of student 2",user.full_name) self.assertEquals("*****@*****.**",user.email) self.ups.logout(sess_id)
def test_get_roles(self): db_sess_id = DatabaseSession.ValidDatabaseSessionId('student1', "student") sess_id, _ = self.ups.do_reserve_session(db_sess_id) roles = self.ups.get_roles(sess_id) self.ups.logout(sess_id) self.assertEquals(3, len(roles) ) role_names = list( role.name for role in roles ) self.assertTrue( 'student' in role_names ) self.assertTrue( 'professor' in role_names ) self.assertTrue( 'administrator' in role_names )
def check_credentials(self, username, password): try: role, user_id, user_auths = self._auth_gateway.check_user_password( username, password) except DbErrors.DbInvalidUserOrPasswordError: return DbSession.InvalidDatabaseSessionId() if user_auths is None: return DbSession.ValidDatabaseSessionId(username, role.name) else: return DbSession.NotAuthenticatedSessionId(username, role.name, user_auths)
def test_get_experiment_use_by_id_found(self): reservations, usages = self._store_two_reservations() db_sess_id = DatabaseSession.ValidDatabaseSessionId('student1', "student") sess_id, _ = self.ups.do_reserve_session(db_sess_id) finished_result = self.ups.get_experiment_use_by_id(sess_id, reservations[0]) self.assertTrue( finished_result.is_finished() ) # reservation_id1 is for student1, so it returns a real object (with a real experiment_use_id) finished_result.experiment_use.experiment_use_id = None self.assertEquals(FinishedReservationResult(usages[0].load_files('.')), finished_result)
def test_list_all_users(self): first_time = time.time() db_sess_id = DatabaseSession.ValidDatabaseSessionId('student2', "student") sess_id, _ = self.ups.do_reserve_session(db_sess_id) result = methods.list_all_users.call() self.assertEquals(1, len(result)) session_id, user_info, latest = result[0] current_time = time.time() + 1 self.assertTrue( first_time <= latest <= current_time ) self.assertEquals( 'student2', user_info.login )
def test_get_user_permissions(self): db_sess_id = DatabaseSession.ValidDatabaseSessionId('student1', "student") sess_id, _ = self.ups.do_reserve_session(db_sess_id) permissions = self.ups.get_user_permissions(sess_id) self.ups.logout(sess_id) self.assertEquals(7, len(permissions)) self.assertEquals('experiment_allowed', permissions[0].name) self.assertEquals(3, len(permissions[0].parameters)) # We only check the first permission's parameters, all of them would be death... self.assertEquals('experiment_permanent_id', permissions[0].parameters[0].name) self.assertEquals('string', permissions[0].parameters[0].datatype) self.assertEquals('ud-fpga', permissions[0].parameters[0].value) self.assertEquals('experiment_category_id', permissions[0].parameters[1].name) self.assertEquals('string', permissions[0].parameters[1].datatype) self.assertEquals('FPGA experiments', permissions[0].parameters[1].value) self.assertEquals('time_allowed', permissions[0].parameters[2].name) self.assertEquals('float', permissions[0].parameters[2].datatype) self.assertEquals('300', permissions[0].parameters[2].value) self.assertEquals('experiment_allowed', permissions[1].name) self.assertEquals(3, len(permissions[1].parameters)) self.assertEquals('experiment_allowed', permissions[2].name) self.assertEquals(3, len(permissions[2].parameters)) self.assertEquals('experiment_allowed', permissions[3].name) self.assertEquals(3, len(permissions[3].parameters)) self.assertEquals('experiment_allowed', permissions[4].name) self.assertEquals(3, len(permissions[4].parameters)) self.assertEquals('experiment_allowed', permissions[5].name) self.assertEquals(3, len(permissions[5].parameters)) self.assertEquals('admin_panel_access', permissions[6].name) self.assertEquals(1, len(permissions[6].parameters)) # Ok, the last one too... it's short! self.assertEquals('full_privileges', permissions[6].parameters[0].name) self.assertEquals('bool', permissions[6].parameters[0].datatype) self.assertEquals('1', permissions[6].parameters[0].value)
def test_get_experiment_uses_by_id_found(self): reservations, usages = self._store_two_reservations() db_sess_id = DatabaseSession.ValidDatabaseSessionId('student1', "student") sess_id, _ = self.ups.do_reserve_session(db_sess_id) experiment_results = self.ups.get_experiment_uses_by_id(sess_id, reservations) self.assertEquals(2, len(experiment_results)) self.assertTrue( experiment_results[0].is_finished() ) # reservation_id1 is for student1, so it returns a real object (with a real experiment_use_id) experiment_results[0].experiment_use.experiment_use_id = None self.assertEquals(FinishedReservationResult(usages[0].load_files('.')), experiment_results[0]) # reservation_id2 is for student2, and the session is for student1, so it is forbidden self.assertTrue(experiment_results[1].is_forbidden())
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_list_all_users_invalid_user(self): first_time = time.time() db_sess_id = DatabaseSession.ValidDatabaseSessionId('student2', "student") sess_id, _ = self.ups.do_reserve_session(db_sess_id) sess_mgr = self.ups._session_manager sess_obj = sess_mgr.get_session(sess_id) sess_obj.pop('user_information') result = methods.list_all_users.call() self.assertEquals(1, len(result)) session_id, user_info, latest = result[0] current_time = time.time() + 1 self.assertTrue( first_time <= latest <= current_time ) self.assertEquals( '<unknown>', user_info.login )
def test_get_experiments(self): db_sess_id = DatabaseSession.ValidDatabaseSessionId('student1', "student") sess_id, _ = self.ups.do_reserve_session(db_sess_id) experiments = self.ups.get_experiments(sess_id) self.ups.logout(sess_id) self.assertTrue( len(experiments) > 14 ) unique_names = [ exp.get_unique_name() for exp in experiments ] self.assertTrue('flashdummy@Dummy experiments' in unique_names) self.assertTrue('javadummy@Dummy experiments' in unique_names) self.assertTrue('ud-dummy@Dummy experiments' in unique_names) self.assertTrue('visirtest@Dummy experiments' in unique_names) self.assertTrue('vm@Dummy experiments' in unique_names) self.assertTrue('ud-fpga@FPGA experiments' in unique_names) self.assertTrue('ud-gpib@GPIB experiments' in unique_names) self.assertTrue('ud-logic@PIC experiments' in unique_names) self.assertTrue('ud-pld@PLD experiments' in unique_names) self.assertTrue('ud-pld2@PLD experiments' in unique_names)
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 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 iterate_initial(self): initial_information = self.initial_store.get(timeout=self.timeout) if initial_information is not None: initial_timestamp = time.mktime(initial_information.initial_time.timetuple()) + initial_information.initial_time.microsecond / 10e6 end_timestamp = time.mktime(initial_information.end_time.timetuple()) + initial_information.end_time.microsecond / 10e6 request_info = initial_information.request_info from_ip = request_info.pop('from_ip','<address not found>') try: username = request_info.pop('username') role = request_info.pop('role') except: log.log( TemporalInformationRetriever, log.level.Critical, "Provided information did not contain some required fields (such as username or role). This usually means that the reservation has previously been expired. Provided request_info: %r; provided data: %r" % (request_info, initial_information), max_size = 10000) log.log_exc( TemporalInformationRetriever, log.level.Critical ) return usage = ExperimentUsage() usage.start_date = initial_timestamp usage.from_ip = from_ip usage.experiment_id = initial_information.experiment_id usage.reservation_id = initial_information.reservation_id usage.coord_address = initial_information.exp_coordaddr usage.request_info = initial_information.request_info command_request = CommandSent( Command.Command("@@@initial::request@@@"), initial_timestamp, Command.Command(str(initial_information.client_initial_data)), end_timestamp) command_response = CommandSent( Command.Command("@@@initial::response@@@"), initial_timestamp, Command.Command(str(initial_information.initial_configuration)), end_timestamp) usage.append_command(command_request) usage.append_command(command_response) self.db_manager.store_experiment_usage(DbSession.ValidDatabaseSessionId(username, role), usage)
def check_external_credentials(self, credentials, system): login, role = self._auth_gateway.check_external_credentials( credentials, system) return DbSession.ValidDatabaseSessionId(login, role.name)
def iterate_completed(self): completed_information = self.completed_store.get(timeout=self.timeout) if completed_information is not None: username, usage, callback = completed_information self.db_manager.store_experiment_usage(DbSession.ValidDatabaseSessionId(username, ''), usage) callback()
def test_get_reservation_id_no_one_using_it(self): db_sess_id = DatabaseSession.ValidDatabaseSessionId('student2', "student") sess_id1, _ = self.ups.do_reserve_session(db_sess_id) reservation_id = methods.get_reservation_id.call(sess_id1.id) self.assertEquals(None, reservation_id)