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)
