def setUpClass(cls):
cls._access_key = HydrusData.GenerateKey()
cls._serverside_file_service = HydrusNetwork.GenerateService(
HydrusData.GenerateKey(), HC.FILE_REPOSITORY, 'file repo',
HC.DEFAULT_SERVICE_PORT + 1)
cls._serverside_tag_service = HydrusNetwork.GenerateService(
HydrusData.GenerateKey(), HC.TAG_REPOSITORY, 'tag repo',
HC.DEFAULT_SERVICE_PORT)
cls._serverside_admin_service = HydrusNetwork.GenerateService(
HydrusData.GenerateKey(), HC.SERVER_ADMIN, 'server admin',
HC.DEFAULT_SERVER_ADMIN_PORT)
cls._clientside_file_service = ClientServices.GenerateService(
HydrusData.GenerateKey(), HC.FILE_REPOSITORY, 'file repo')
cls._clientside_tag_service = ClientServices.GenerateService(
HydrusData.GenerateKey(), HC.TAG_REPOSITORY, 'tag repo')
cls._clientside_admin_service = ClientServices.GenerateService(
HydrusData.GenerateKey(), HC.SERVER_ADMIN, 'server admin')
cls._clientside_file_service.SetCredentials(
HydrusNetwork.Credentials('127.0.0.1', HC.DEFAULT_SERVICE_PORT + 1,
cls._access_key))
cls._clientside_tag_service.SetCredentials(
HydrusNetwork.Credentials('127.0.0.1', HC.DEFAULT_SERVICE_PORT,
cls._access_key))
cls._clientside_admin_service.SetCredentials(
HydrusNetwork.Credentials('127.0.0.1',
HC.DEFAULT_SERVER_ADMIN_PORT,
cls._access_key))
cls._local_booru = ClientServices.GenerateService(
CC.LOCAL_BOORU_SERVICE_KEY, HC.LOCAL_BOORU, 'local booru')
services_manager = HG.test_controller.services_manager
services_manager._keys_to_services[
cls._clientside_file_service.GetServiceKey(
)] = cls._clientside_file_service
services_manager._keys_to_services[
cls._clientside_tag_service.GetServiceKey(
)] = cls._clientside_tag_service
services_manager._keys_to_services[
cls._clientside_admin_service.GetServiceKey(
)] = cls._clientside_admin_service
account_key = HydrusData.GenerateKey()
account_type = HydrusNetwork.AccountType.GenerateAdminAccountType(
HC.SERVER_ADMIN)
created = HydrusData.GetNow() - 100000
expires = None
cls._account = HydrusNetwork.Account(account_key, account_type,
created, expires)
cls._service_keys_to_empty_account_types = {}
cls._service_keys_to_empty_accounts = {}
cls._file_hash = HydrusData.GenerateKey()
def TWISTEDSetup():
cls._ssl_cert_path = os.path.join(TestController.DB_DIR,
'server.crt')
cls._ssl_key_path = os.path.join(TestController.DB_DIR,
'server.key')
# if db test ran, this is still hanging around and read-only, so don't bother to fail overwriting
if not os.path.exists(cls._ssl_cert_path):
HydrusEncryption.GenerateOpenSSLCertAndKeyFile(
cls._ssl_cert_path, cls._ssl_key_path)
context_factory = twisted.internet.ssl.DefaultOpenSSLContextFactory(
cls._ssl_key_path, cls._ssl_cert_path)
reactor.listenSSL(
HC.DEFAULT_SERVER_ADMIN_PORT,
ServerServer.HydrusServiceAdmin(cls._serverside_admin_service),
context_factory)
reactor.listenSSL(
HC.DEFAULT_SERVICE_PORT + 1,
ServerServer.HydrusServiceRepositoryFile(
cls._serverside_file_service), context_factory)
reactor.listenSSL(
HC.DEFAULT_SERVICE_PORT,
ServerServer.HydrusServiceRepositoryTag(
cls._serverside_tag_service), context_factory)
reactor.listenTCP(
45866,
ClientLocalServer.HydrusServiceBooru(
cls._local_booru, allow_non_local_connections=False))
reactor.callFromThread(TWISTEDSetup)
time.sleep(3)
def test_server(self):
discard = HG.test_controller.GetWrite(
'session') # just to discard gumph from testserver
session_key_1 = HydrusData.GenerateKey()
service_key = HydrusData.GenerateKey()
permissions = [
HC.GET_DATA, HC.POST_DATA, HC.POST_PETITIONS, HC.RESOLVE_PETITIONS,
HC.MANAGE_USERS, HC.GENERAL_ADMIN, HC.EDIT_SERVICES
]
account_type = HydrusNetwork.AccountType.GenerateAdminAccountType(
HC.SERVER_ADMIN)
created = HydrusData.GetNow() - 100000
expires = HydrusData.GetNow() + 300
account_key_1 = HydrusData.GenerateKey()
account_key_2 = HydrusData.GenerateKey()
access_key_1 = HydrusData.GenerateKey()
hashed_access_key_1 = hashlib.sha256(access_key_1).digest()
access_key_2 = HydrusData.GenerateKey()
hashed_access_key_2 = hashlib.sha256(access_key_2).digest()
account = HydrusNetwork.Account(account_key_1, account_type, created,
expires)
account_2 = HydrusNetwork.Account(account_key_2, account_type, created,
expires)
# test timeout
expires = HydrusData.GetNow() - 10
HG.test_controller.SetRead('sessions', [
(session_key_1, service_key, account, hashed_access_key_1, expires)
])
session_manager = HydrusSessions.HydrusSessionManagerServer()
with self.assertRaises(HydrusExceptions.SessionException):
session_manager.GetAccount(service_key, session_key_1)
# test missing
with self.assertRaises(HydrusExceptions.SessionException):
session_manager.GetAccount(service_key, HydrusData.GenerateKey())
# test fetching a session already in db, after bootup
expires = HydrusData.GetNow() + 300
HG.test_controller.SetRead('sessions', [
(session_key_1, service_key, account, hashed_access_key_1, expires)
])
session_manager = HydrusSessions.HydrusSessionManagerServer()
read_account = session_manager.GetAccount(service_key, session_key_1)
self.assertIs(read_account, account)
read_account = session_manager.GetAccountFromAccessKey(
service_key, access_key_1)
self.assertIs(read_account, account)
# test too busy to add a new session for a new account it doesn't know about
HG.server_busy.acquire()
with self.assertRaises(HydrusExceptions.ServerBusyException):
session_manager.AddSession(service_key, HydrusData.GenerateKey())
session_manager.GetAccountFromAccessKey(service_key,
HydrusData.GenerateKey())
# but ok to get for a session that already exists while busy
session_manager.GetAccount(service_key, session_key_1)
session_manager.GetAccountFromAccessKey(service_key, access_key_1)
HG.server_busy.release()
# test adding a session
HG.test_controller.ClearWrites('session')
expires = HydrusData.GetNow() + 300
HG.test_controller.SetRead('account_key_from_access_key',
account_key_2)
HG.test_controller.SetRead('account', account_2)
(session_key_2,
expires_2) = session_manager.AddSession(service_key, access_key_2)
[(args, kwargs)] = HG.test_controller.GetWrite('session')
(written_session_key, written_service_key, written_account_key,
written_expires) = args
self.assertEqual(
(session_key_2, service_key, account_key_2, expires_2),
(written_session_key, written_service_key, written_account_key,
written_expires))
read_account = session_manager.GetAccount(service_key, session_key_2)
self.assertIs(read_account, account_2)
read_account = session_manager.GetAccountFromAccessKey(
service_key, access_key_2)
self.assertIs(read_account, account_2)
# test adding a new session for an account already in the manager
HG.test_controller.SetRead('account_key_from_access_key',
account_key_1)
HG.test_controller.SetRead('account', account)
(session_key_3,
expires_3) = session_manager.AddSession(service_key, access_key_1)
[(args, kwargs)] = HG.test_controller.GetWrite('session')
(written_session_key, written_service_key, written_account_key,
written_expires) = args
self.assertEqual(
(session_key_3, service_key, account_key_1, expires_3),
(written_session_key, written_service_key, written_account_key,
written_expires))
read_account = session_manager.GetAccount(service_key, session_key_1)
self.assertIs(read_account, account)
read_account = session_manager.GetAccount(service_key, session_key_3)
self.assertIs(read_account, account)
read_account = session_manager.GetAccountFromAccessKey(
service_key, access_key_1)
self.assertIs(read_account, account)
# test individual account refresh
expires = HydrusData.GetNow() + 300
new_obj_account_1 = HydrusNetwork.Account(account_key_1, account_type,
created, expires)
HG.test_controller.SetRead('account', new_obj_account_1)
session_manager.RefreshAccounts(service_key, [account_key_1])
read_account = session_manager.GetAccount(service_key, session_key_1)
self.assertIs(read_account, new_obj_account_1)
read_account = session_manager.GetAccount(service_key, session_key_3)
self.assertIs(read_account, new_obj_account_1)
read_account = session_manager.GetAccountFromAccessKey(
service_key, access_key_1)
self.assertIs(read_account, new_obj_account_1)
# test all account refresh
expires = HydrusData.GetNow() + 300
new_obj_account_2 = HydrusNetwork.Account(account_key_2, account_type,
created, expires)
HG.test_controller.SetRead(
'sessions', [(session_key_1, service_key, new_obj_account_2,
hashed_access_key_2, expires),
(session_key_2, service_key, new_obj_account_1,
hashed_access_key_1, expires),
(session_key_3, service_key, new_obj_account_2,
hashed_access_key_2, expires)])
session_manager.RefreshAllAccounts()
read_account = session_manager.GetAccount(service_key, session_key_1)
self.assertIs(read_account, new_obj_account_2)
read_account = session_manager.GetAccount(service_key, session_key_2)
self.assertIs(read_account, new_obj_account_1)
read_account = session_manager.GetAccount(service_key, session_key_3)
self.assertIs(read_account, new_obj_account_2)
read_account = session_manager.GetAccountFromAccessKey(
service_key, access_key_1)
self.assertIs(read_account, new_obj_account_1)
read_account = session_manager.GetAccountFromAccessKey(
service_key, access_key_2)
self.assertIs(read_account, new_obj_account_2)
