shaba/openuds
1
0
Fork 1
mirror of https://github.com/dkmstr/openuds.git synced 2025-02-02 09:47:13 +03:00
Code Issues Releases Wiki Activity

some minor refactoring of userservice names

Browse Source
This commit is contained in:
Adolfo Gómez García 2024-09-11 17:39:35 +02:00
parent efc4244367
commit 0524a1bc78
No known key found for this signature in database
GPG Key ID: DD1ABF20724CDA23
14 changed files with 115 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
server/src/tests/core/managers/test_servers_managed.py
View File

@ -123,10 +123,10 @@ class ServerManagerManagedServersTest(UDSTestCase):
def test_auto_assign(self) -> None:
with self.create_mock_api_requester() as mockServerApiRequester:
for elementNumber, userService in enumerate(self.user_services):
expected_get_stats_calls = NUM_REGISTEREDSERVERS * (elementNumber + 1)
expected_notify_assign_calls = elementNumber * 33 # 32 in loop + 1 in first assign
assignation = self.assign(userService)
for element_number, userservice in enumerate(self.user_services):
expected_get_stats_calls = NUM_REGISTEREDSERVERS * (element_number + 1)
expected_notify_assign_calls = element_number * 33 # 32 in loop + 1 in first assign
assignation = self.assign(userservice)
if assignation is None:
self.fail('Assignation returned None')
return # For mypy
@ -136,7 +136,7 @@ class ServerManagerManagedServersTest(UDSTestCase):
self.server_stats[uuid], current_users=self.server_stats[uuid].current_users + 1
)
prop_name = self.manager.property_name(userService.user)
prop_name = self.manager.property_name(userservice.user)
# uuid shuld be one on registered servers
self.assertTrue(uuid in self.all_uuids)
# Server locked should be None
@ -146,17 +146,17 @@ class ServerManagerManagedServersTest(UDSTestCase):
self.assertEqual(
mockServerApiRequester.return_value.get_stats.call_count,
expected_get_stats_calls,
f'Error on loop {elementNumber}',
f'Error on loop {element_number}',
)
# notify_assign should has been called once for each user service
self.assertEqual(
mockServerApiRequester.return_value.notify_assign.call_count, expected_notify_assign_calls + 1
)
# notify_assign paramsh should have been
# request.ServerApiRequester(bestServer).notify_assign(userService, serviceType, uuid_counter[1])
# request.ServerApiRequester(bestServer).notify_assign(userservice, serviceType, uuid_counter[1])
self.assertEqual(
mockServerApiRequester.return_value.notify_assign.call_args[0][0], userService
) # userService
mockServerApiRequester.return_value.notify_assign.call_args[0][0], userservice
) # userservice
self.assertEqual(
mockServerApiRequester.return_value.notify_assign.call_args[0][1],
types.services.ServiceType.VDI,
@ -166,7 +166,7 @@ class ServerManagerManagedServersTest(UDSTestCase):
) # counter
# Server storage should contain the assignation
self.assertEqual(len(self.registered_servers_group.properties), elementNumber + 1)
self.assertEqual(len(self.registered_servers_group.properties), element_number + 1)
uuid_counter = self.registered_servers_group.properties[prop_name]
# uuid_counter is (uuid, assign counter)
self.assertEqual(uuid_counter[0], uuid)
@ -174,7 +174,7 @@ class ServerManagerManagedServersTest(UDSTestCase):
# Again, try to assign, same user service, same group, same service type, same minMemoryMB and same uuid
for i in range(32):
assignation = self.assign(userService)
assignation = self.assign(userservice)
if assignation is None:
self.fail('Assignation returned None')
return # For mypy
@ -196,28 +196,28 @@ class ServerManagerManagedServersTest(UDSTestCase):
)
# Server storage should have elementNumber + 1 elements
self.assertEqual(len(self.registered_servers_group.properties), elementNumber + 1)
self.assertEqual(len(self.registered_servers_group.properties), element_number + 1)
uuid_counter = self.registered_servers_group.properties[prop_name]
# uuid_counter is (uuid, assign counter)
self.assertEqual(uuid_counter[0], uuid)
self.assertEqual(uuid_counter[1], counter)
# Now, remove all asignations..
for elementNumber, userService in enumerate(self.user_services):
expected_get_stats_calls = NUM_REGISTEREDSERVERS * (elementNumber + 1)
expected_notify_assign_calls = elementNumber * 33 # 32 in loop + 1 in first assign
for element_number, userservice in enumerate(self.user_services):
expected_get_stats_calls = NUM_REGISTEREDSERVERS * (element_number + 1)
expected_notify_assign_calls = element_number * 33 # 32 in loop + 1 in first assign
# # Remove it, should decrement counter
for i in range(32, -1, -1): # Deletes 33 times
_res = self.manager.release(userService, self.registered_servers_group)
_res = self.manager.release(userservice, self.registered_servers_group)
self.assertEqual(len(self.registered_servers_group.properties), 0)
def test_assign_auto_lock_limit(self) -> None:
with self.create_mock_api_requester() as mockServerApiRequester:
# Assign all user services with lock
for userService in self.user_services[:NUM_REGISTEREDSERVERS]:
assignation = self.assign(userService, lock_interval=datetime.timedelta(seconds=1))
for userservice in self.user_services[:NUM_REGISTEREDSERVERS]:
assignation = self.assign(userservice, lock_interval=datetime.timedelta(seconds=1))
if assignation is None:
self.fail('Assignation returned None')
return # For mypy
@ -245,12 +245,12 @@ class ServerManagerManagedServersTest(UDSTestCase):
with self.create_mock_api_requester() as mockServerApiRequester:
serverApiRequester = mockServerApiRequester.return_value
for assignations in range(2): # Second pass will get current assignation, not new ones
for elementNumber, userService in enumerate(self.user_services[:NUM_REGISTEREDSERVERS]):
for element_number, userservice in enumerate(self.user_services[:NUM_REGISTEREDSERVERS]):
# Ensure locking server, so we have to use every server only once
assignation = self.assign(userService, lock_interval=datetime.timedelta(seconds=32))
assignation = self.assign(userservice, lock_interval=datetime.timedelta(seconds=32))
self.assertEqual(
serverApiRequester.notify_assign.call_count,
assignations * NUM_REGISTEREDSERVERS + elementNumber + 1,
assignations * NUM_REGISTEREDSERVERS + element_number + 1,
)
if assignation is None:
self.fail('Assignation returned None')
@ -280,8 +280,8 @@ class ServerManagerManagedServersTest(UDSTestCase):
# Now release all, twice
for release in range(2):
for elementNumber, userService in enumerate(self.user_services[:NUM_REGISTEREDSERVERS]):
res = self.manager.release(userService, self.registered_servers_group)
for element_number, userservice in enumerate(self.user_services[:NUM_REGISTEREDSERVERS]):
res = self.manager.release(userservice, self.registered_servers_group)
if res:
uuid, counter = res
# uuid shuld be one on registered servers
@ -292,8 +292,8 @@ class ServerManagerManagedServersTest(UDSTestCase):
self.fail('Release returned None')
self.assertEqual(
serverApiRequester.notify_release.call_count,
release * NUM_REGISTEREDSERVERS + elementNumber + 1,
f'Error on loop {release} - {elementNumber}',
release * NUM_REGISTEREDSERVERS + element_number + 1,
f'Error on loop {release} - {element_number}',
)
# All servers should be unlocked
@ -306,8 +306,8 @@ class ServerManagerManagedServersTest(UDSTestCase):
self.assertEqual(len(stor), 0)
# Trying to release again should return '', 0
for elementNumber, userService in enumerate(self.user_services[:NUM_REGISTEREDSERVERS]):
res = self.manager.release(userService, self.registered_servers_group)
for element_number, userservice in enumerate(self.user_services[:NUM_REGISTEREDSERVERS]):
res = self.manager.release(userservice, self.registered_servers_group)
if res:
uuid, counter = res
self.assertEqual(uuid, '')

38
server/src/tests/core/managers/test_servers_unmanaged.py
View File

@ -92,15 +92,15 @@ class ServerManagerUnmanagedServersTest(UDSTestCase):
def testAssignAuto(self) -> None:
with self.createMockApiRequester() as mockServerApiRequester:
for elementNumber, userService in enumerate(self.user_services[:NUM_REGISTEREDSERVERS]):
expected_get_stats_calls = NUM_REGISTEREDSERVERS * (elementNumber + 1)
expected_notify_assign_calls = elementNumber * 33 # 32 in loop + 1 in first assign
assignation = self.assign(userService)
for element_number, userservice in enumerate(self.user_services[:NUM_REGISTEREDSERVERS]):
expected_get_stats_calls = NUM_REGISTEREDSERVERS * (element_number + 1)
expected_notify_assign_calls = element_number * 33 # 32 in loop + 1 in first assign
assignation = self.assign(userservice)
if assignation is None:
self.fail('Assignation returned None')
return # For mypy
uuid, counter = assignation
prop_name = self.manager.property_name(userService.user)
prop_name = self.manager.property_name(userservice.user)
# uuid shuld be one on registered servers
self.assertTrue(uuid in self.all_uuids)
# Server locked should be None
@ -110,17 +110,17 @@ class ServerManagerUnmanagedServersTest(UDSTestCase):
self.assertEqual(
mockServerApiRequester.return_value.get_stats.call_count,
expected_get_stats_calls,
f'Error on loop {elementNumber}',
f'Error on loop {element_number}',
)
# notify_assign should has been called once for each user service
self.assertEqual(
mockServerApiRequester.return_value.notify_assign.call_count, expected_notify_assign_calls + 1
)
# notify_assign paramsh should have been
# request.ServerApiRequester(bestServer).notify_assign(userService, serviceType, uuid_counter[1])
# request.ServerApiRequester(bestServer).notify_assign(userservice, serviceType, uuid_counter[1])
self.assertEqual(
mockServerApiRequester.return_value.notify_assign.call_args[0][0], userService
) # userService
mockServerApiRequester.return_value.notify_assign.call_args[0][0], userservice
) # userservice
self.assertEqual(
mockServerApiRequester.return_value.notify_assign.call_args[0][1],
types.services.ServiceType.VDI,
@ -130,12 +130,12 @@ class ServerManagerUnmanagedServersTest(UDSTestCase):
) # counter
# Server storage should contain the assignation
self.assertEqual(len(self.registered_servers_group.properties), elementNumber + 1)
self.assertEqual(len(self.registered_servers_group.properties), element_number + 1)
self.assertEqual(self.registered_servers_group.properties[prop_name], [uuid, counter])
# Again, try to assign, same user service, same group, same service type, same minMemoryMB and same uuid
for i in range(32):
assignation = self.assign(userService)
assignation = self.assign(userservice)
if assignation is None:
self.fail('Assignation returned None')
return # For mypy
@ -156,26 +156,26 @@ class ServerManagerUnmanagedServersTest(UDSTestCase):
expected_notify_assign_calls + i + 2,
)
self.assertEqual(len(self.registered_servers_group.properties), elementNumber + 1)
self.assertEqual(len(self.registered_servers_group.properties), element_number + 1)
self.assertEqual(self.registered_servers_group.properties[prop_name], [uuid, counter])
# Now, remove all asignations..
for elementNumber, userService in enumerate(self.user_services[:NUM_REGISTEREDSERVERS]):
expected_get_stats_calls = NUM_REGISTEREDSERVERS * (elementNumber + 1)
expected_notify_assign_calls = elementNumber * 33 # 32 in loop + 1 in first assign
prop_name = self.manager.property_name(userService.user)
for element_number, userservice in enumerate(self.user_services[:NUM_REGISTEREDSERVERS]):
expected_get_stats_calls = NUM_REGISTEREDSERVERS * (element_number + 1)
expected_notify_assign_calls = element_number * 33 # 32 in loop + 1 in first assign
prop_name = self.manager.property_name(userservice.user)
# # Remove it, should decrement counter
for i in range(32, -1, -1): # Deletes 33 times
_res = self.manager.release(userService, self.registered_servers_group)
_res = self.manager.release(userservice, self.registered_servers_group)
self.assertEqual(len(self.registered_servers_group.properties), 0)
def test_assign_autolock_limit(self) -> None:
with self.createMockApiRequester() as mockServerApiRequester:
# Assign all user services with lock
for userService in self.user_services[:NUM_REGISTEREDSERVERS]:
assignation = self.assign(userService, lock_interval=datetime.timedelta(seconds=1.1))
for userservice in self.user_services[:NUM_REGISTEREDSERVERS]:
assignation = self.assign(userservice, lock_interval=datetime.timedelta(seconds=1.1))
if assignation is None:
self.fail('Assignation returned None')
return # For mypy

6
server/src/uds/REST/methods/authenticators.py
View File

@ -278,8 +278,8 @@ class Authenticators(ModelHandler):
item = ensure.is_instance(item, Authenticator)
for user in item.users.all():
for userService in user.userServices.all():
userService.user = None
userService.remove_or_cancel()
for userservice in user.userServices.all():
userservice.user = None
userservice.remove_or_cancel()
item.delete()

20
server/src/uds/REST/methods/meta_service_pools.py
View File

@ -244,22 +244,22 @@ class MetaAssignedService(DetailHandler):
def delete_item(self, parent: 'Model', item: str) -> None:
parent = ensure.is_instance(parent, models.MetaPool)
userService = self._get_assigned_userservice(parent, item)
userservice = self._get_assigned_userservice(parent, item)
if userService.user:
if userservice.user:
logStr = 'Deleted assigned service {} to user {} by {}'.format(
userService.friendly_name,
userService.user.pretty_name,
userservice.friendly_name,
userservice.user.pretty_name,
self._user.pretty_name,
)
else:
logStr = 'Deleted cached service {} by {}'.format(userService.friendly_name, self._user.pretty_name)
logStr = 'Deleted cached service {} by {}'.format(userservice.friendly_name, self._user.pretty_name)
if userService.state in (State.USABLE, State.REMOVING):
userService.release()
elif userService.state == State.PREPARING:
userService.cancel()
elif userService.state == State.REMOVABLE:
if userservice.state in (State.USABLE, State.REMOVING):
userservice.release()
elif userservice.state == State.PREPARING:
userservice.cancel()
elif userservice.state == State.REMOVABLE:
raise self.invalid_item_response(_('Item already being removed'))
else:
raise self.invalid_item_response(_('Item is not removable'))

14
server/src/uds/REST/methods/services_usage.py
View File

@ -135,20 +135,20 @@ class ServicesUsage(DetailHandler):
def delete_item(self, parent: 'Model', item: str) -> None:
parent = ensure.is_instance(parent, Provider)
userService: UserService
userservice: UserService
try:
userService = UserService.objects.get(
userservice = UserService.objects.get(
uuid=process_uuid(item), deployed_service__service__provider=parent
)
except Exception:
raise self.invalid_item_response()
logger.debug('Deleting user service')
if userService.state in (State.USABLE, State.REMOVING):
userService.release()
elif userService.state == State.PREPARING:
userService.cancel()
elif userService.state == State.REMOVABLE:
if userservice.state in (State.USABLE, State.REMOVING):
userservice.release()
elif userservice.state == State.PREPARING:
userservice.cancel()
elif userservice.state == State.REMOVABLE:
raise self.invalid_item_response(_('Item already being removed'))
else:
raise self.invalid_item_response(_('Item is not removable'))

18
server/src/uds/REST/methods/user_services.py
View File

@ -205,21 +205,21 @@ class AssignedService(DetailHandler):
def delete_item(self, parent: 'Model', item: str) -> None:
parent = ensure.is_instance(parent, models.ServicePool)
try:
userService: models.UserService = parent.userServices.get(uuid=process_uuid(item))
userservice: models.UserService = parent.userServices.get(uuid=process_uuid(item))
except Exception as e:
logger.exception('delete_item')
raise self.invalid_item_response() from e
if userService.user:
logStr = f'Deleted assigned service {userService.friendly_name} to user {userService.user.pretty_name} by {self._user.pretty_name}'
if userservice.user:
logStr = f'Deleted assigned service {userservice.friendly_name} to user {userservice.user.pretty_name} by {self._user.pretty_name}'
else:
logStr = f'Deleted cached service {userService.friendly_name} by {self._user.pretty_name}'
logStr = f'Deleted cached service {userservice.friendly_name} by {self._user.pretty_name}'
if userService.state in (State.USABLE, State.REMOVING):
userService.release()
elif userService.state == State.PREPARING:
userService.cancel()
elif userService.state == State.REMOVABLE:
if userservice.state in (State.USABLE, State.REMOVING):
userservice.release()
elif userservice.state == State.PREPARING:
userservice.cancel()
elif userservice.state == State.REMOVABLE:
raise self.invalid_item_response(_('Item already being removed'))
else:
raise self.invalid_item_response(_('Item is not removable'))

14
server/src/uds/core/managers/servers_api/events.py
View File

@ -131,17 +131,17 @@ def process_logout(server: 'models.Server', data: dict[str, typing.Any]) -> typi
Returns 'OK' if all went ok ({'result': 'OK', 'stamp': 'stamp'}), or an error if not ({'result': 'error', 'error': 'error description'}})
"""
userService = models.UserService.objects.get(uuid=data['userservice_uuid'])
userservice = models.UserService.objects.get(uuid=data['userservice_uuid'])
session_id = data['userservice_uuid']
userService.end_session(session_id)
userservice.end_session(session_id)
if userService.in_use: # If already logged out, do not add a second logout (windows does this i.e.)
osmanagers.OSManager.logged_out(userService, data['username'])
osmanager: typing.Optional[osmanagers.OSManager] = userService.get_osmanager_instance()
if not osmanager or osmanager.is_removable_on_logout(userService):
if userservice.in_use: # If already logged out, do not add a second logout (windows does this i.e.)
osmanagers.OSManager.logged_out(userservice, data['username'])
osmanager: typing.Optional[osmanagers.OSManager] = userservice.get_osmanager_instance()
if not osmanager or osmanager.is_removable_on_logout(userservice):
logger.debug('Removable on logout: %s', osmanager)
userService.release()
userservice.release()
return rest_result(consts.OK)

4
server/src/uds/core/managers/userservice.py
View File

@ -359,7 +359,7 @@ class UserServiceManager(metaclass=singleton.Singleton):
service_instance = servicepool.service.get_instance()
servicepool.user_services.update() # Cleans cached queries
servicepool.userservices.update() # Cleans cached queries
# If this deployedService don't have a publication active and needs it, ignore it
service_instance = servicepool.service.get_instance()
@ -400,7 +400,7 @@ class UserServiceManager(metaclass=singleton.Singleton):
l2_cache_filter = self.get_cache_state_filter(servicepool, types.services.CacheLevel.L2)
assigned_filter = self.get_cache_state_filter(servicepool, types.services.CacheLevel.NONE)
counts: dict[str, int] = servicepool.user_services.aggregate(
counts: dict[str, int] = servicepool.userservices.aggregate(
l1_cache_count=Count(Case(When(l1_cache_filter, then=1), output_field=IntegerField()))
+ l1_cache_increased_by,
l2_cache_count=Count(Case(When(l2_cache_filter, then=1), output_field=IntegerField()))

8
server/src/uds/models/calendar_action.py
View File

@ -167,18 +167,18 @@ class CalendarAction(UUIDModel):
def _remove_userservices() -> None:
# 1.- Remove usable assigned services (Ignore "creating ones", just for created)
for userService in self.service_pool.assigned_user_services().filter(
for userservice in self.service_pool.assigned_user_services().filter(
state=types.states.State.USABLE
):
userService.release()
userservice.release()
def _remove_stuck_userservice() -> None:
# 1.- Remove stuck assigned services (Ignore "creating ones", just for created)
since = sql_now() - datetime.timedelta(hours=_numeric_value('hours'))
for userService in self.service_pool.assigned_user_services().filter(
for userservice in self.service_pool.assigned_user_services().filter(
state_date__lt=since, state=types.states.State.USABLE
):
userService.release()
userservice.release()
def _del_all_transport() -> None:
# 2.- Remove all transports

2
server/src/uds/models/service_pool.py
View File

@ -156,7 +156,7 @@ class ServicePool(UUIDModel, TaggingMixin):
# New nomenclature, but keeping old ones for compatibility
@property
def user_services(self) -> 'models.manager.RelatedManager[UserService]':
def userservices(self) -> 'models.manager.RelatedManager[UserService]':
return self.userServices
@property

5
server/src/uds/models/user_service.py
View File

@ -540,6 +540,11 @@ class UserService(UUIDModel, properties.PropertiesMixin):
Mark this user deployed service for removal.
If from_logout is true, maybe the service can return to cache, else, it will be removed
"""
# log backtrace calling this method
# import traceback
# logger.info('Removing user service %s', self)
# logger.info('\n* '.join(traceback.format_stack()))
if immediate:
self.set_state(State.REMOVED)
else:

8
server/src/uds/services/OpenGnsys/jobs.py
View File

@ -70,16 +70,16 @@ class OpenGnsysMaintainer(jobs.Job):
hours=instance.max_reserve_hours.as_int() - 8
) # If less than 8 hours of reservation...
# Now mark for removal every CACHED service that is about to expire its reservation on OpenGnsys
userService: models.UserService
for userService in models.UserService.objects.filter(
userservice: models.UserService
for userservice in models.UserService.objects.filter(
deployed_service__service=service,
creation_date__lt=since,
cache_level=1,
):
logger.info(
'The cached user service %s is about to expire. Removing it so it can be recreated',
userService,
userservice,
)
userService.release()
userservice.release()
logger.debug('OpenGnsys job finished')

28
server/src/uds/web/views/service.py
View File

@ -199,41 +199,41 @@ def user_service_status(
@web_login_required(admin=False)
@never_cache
def action(request: 'ExtendedHttpRequestWithUser', service_id: str, action_string: str) -> HttpResponse:
userService = UserServiceManager.manager().locate_meta_service(request.user, service_id)
if not userService:
userService = UserServiceManager.manager().locate_user_service(request.user, service_id, create=False)
userservice = UserServiceManager.manager().locate_meta_service(request.user, service_id)
if not userservice:
userservice = UserServiceManager.manager().locate_user_service(request.user, service_id, create=False)
response: typing.Any = None
rebuild: bool = False
if userService:
if action_string == 'release' and userService.service_pool.allow_users_remove:
if userservice:
if action_string == 'release' and userservice.service_pool.allow_users_remove:
rebuild = True
log.log(
userService.service_pool,
userservice.service_pool,
types.log.LogLevel.INFO,
"Removing User Service {} as requested by {} from {}".format(
userService.friendly_name, request.user.pretty_name, request.ip
userservice.friendly_name, request.user.pretty_name, request.ip
),
types.log.LogSource.WEB,
)
UserServiceManager.manager().request_logoff(userService)
userService.release()
UserServiceManager.manager().request_logoff(userservice)
userservice.release()
elif (
action_string == 'reset'
and userService.service_pool.allow_users_reset
and userService.service_pool.service.get_type().can_reset
and userservice.service_pool.allow_users_reset
and userservice.service_pool.service.get_type().can_reset
):
rebuild = True
log.log(
userService.service_pool,
userservice.service_pool,
types.log.LogLevel.INFO,
"Reseting User Service {} as requested by {} from {}".format(
userService.friendly_name, request.user.pretty_name, request.ip
userservice.friendly_name, request.user.pretty_name, request.ip
),
types.log.LogSource.WEB,
)
# UserServiceManager.manager().requestLogoff(userService)
UserServiceManager.manager().reset(userService)
UserServiceManager.manager().reset(userservice)
if rebuild:
# Rebuild services data, but return only "this" service

6
server/src/uds/workers/service_pool_cleaner.py
View File

@ -155,9 +155,9 @@ class DeployedServiceRemover(Job):
'Service %s has been in removing state for too long, forcing removal',
servicePool.name,
)
for userService in servicePool.userServices.all():
logger.warning('Force removing user service %s', userService)
userService.delete()
for userservice in servicePool.userServices.all():
logger.warning('Force removing user service %s', userservice)
userservice.delete()
servicePool.userServices.all().delete()
for publication in servicePool.publications.all():
logger.warning('Force removing %s', publication)