def generate_locator(self):
coordinator_server_address = DirectAddress.Address(
'WL_MACHINE1',
'WL_SERVER1',
'coordinator1'
)
server_type_handler = ServerTypeHandler.ServerTypeHandler(
ServerType,
{
ServerType.Coordinator : voodoo_exported_methods.coordinator,
ServerType.Login : weblab_exported_methods.Login,
ServerType.UserProcessing : weblab_exported_methods.UserProcessing,
ServerType.Proxy : weblab_exported_methods.Proxy,
ServerType.Laboratory : weblab_exported_methods.Laboratory,
ServerType.Translator : weblab_exported_methods.Translator,
ServerType.Experiment : weblab_exported_methods.Experiment
}
)
locator = ServerLocator.ServerLocator(
coordinator_server_address,
server_type_handler
)
easy_locator = EasyLocator.EasyLocator(
CoordAddress.CoordAddress('WL_MACHINE1','WL_SERVER1','coordinator1'),
locator
)
return easy_locator
def test_address_constructor(self):
machine_id = 'a'
instance_id = 'b'
server_id = 'c'
addr = DirectAddress.Address(machine_id, instance_id, server_id)
self.assertEquals(addr.machine_id, machine_id)
self.assertEquals(addr.instance_id, instance_id)
self.assertEquals(addr.server_id, server_id)
def test_bad_client_creation(self):
message2 = self.message2
direct_addr = DirectAddress.Address(self.machine_id, self.instance_id,
'wrong_server_id')
self.assertRaises(ProtocolErrors.ClientCreationError,
direct_addr.create_client, self.methods)
cfg_manager = ConfigurationManager.ConfigurationManager()
cfg_manager.append_module(configuration_module)
direct_server_class = ServerSkel.factory(cfg_manager, Protocols.Direct,
self.methods)
class DirectServerClass(direct_server_class):
def do_say_hello(self, msg):
return msg + message2
direct_addr = DirectAddress.Address(self.machine_id, self.instance_id,
self.server_id)
DirectServerClass(Direct=(direct_addr.address, ))
self.assertRaises(ProtocolErrors.ClientClassCreationError,
direct_addr.create_client, 'not valid methods')
def test_direct_create_client(self):
message2 = self.message2
cfg_manager = ConfigurationManager.ConfigurationManager()
cfg_manager.append_module(configuration_module)
direct_server_class = ServerSkel.factory(cfg_manager, Protocols.Direct,
self.methods)
class DirectServerClass(direct_server_class):
def do_say_hello(self, msg):
return msg + message2
direct_addr = DirectAddress.Address(self.machine_id, self.instance_id,
self.server_id)
DirectServerClass(Direct=(direct_addr.address, ))
direct_client = direct_addr.create_client(self.methods)
self.assertEquals(direct_client.say_hello(self.message1),
self.message1 + message2)
def _generate_easy_locator(self, global_config, machine_name,
instance_name, server_name):
coordinator_server_address = DirectAddress.Address(
machine_name, instance_name,
self._generate_coordinator_server_name(machine_name,
instance_name))
server_type, map = self._generate_map_server_type2methods(
global_config)
server_type_handler = ServerTypeHandler.ServerTypeHandler(
server_type, map)
locator = ServerLocator.ServerLocator(coordinator_server_address,
server_type_handler)
server_coord_address = CoordAddress.CoordAddress(
machine_name, instance_name, server_name)
easy_locator = EasyLocator.EasyLocator(server_coord_address, locator)
return easy_locator
def setUp(self):
self._machine_id = 'machine'
self._instance_id = 'instance'
self._server_id = 'coordinator_server_name'
self._login_server1_id = 'login_server_name1'
self._login_server2_id = 'login_server_name2'
cfg_manager = ConfigurationManager.ConfigurationManager()
cfg_manager.append_module(configuration_module)
self.server_type_handler = ServerTypeHandler.ServerTypeHandler(
ServerTypeSample, {
'Login': login_methods,
'Coordinator': coordinator_methods
})
direct_coordinator = ServerSkel.factory(cfg_manager, Protocols.Direct,
coordinator_methods)
class CoordinatorImplementor(direct_coordinator):
def __init__(self, *args, **kargs):
direct_coordinator.__init__(self, *args, **kargs)
def do_new_query(self, address, server_type, restrictions):
return "the session"
def do_get_server(self, session_id):
raise CoordinatorServerErrors.NoServerFoundError(
"No server found for session_id = " + session_id)
def do_get_all_servers(self):
raise NotImplementedError("Not implemented get_all_servers")
def do_get_networks(self):
raise NotImplementedError("Not implemented get_networks")
def do_logout(self, session_id):
pass
self._coordinatorImplementor = CoordinatorImplementor
self.coordinator_server_address = DirectAddress.Address(
self._machine_id, self._instance_id, self._server_id)
self._coordinator_server = CoordinatorImplementor(
Direct=(self.coordinator_server_address.address, ))
direct_login = ServerSkel.factory(cfg_manager, Protocols.Direct,
login_methods)
class LoginImplementor(direct_login):
def __init__(self, *args, **kargs):
direct_login.__init__(self, *args, **kargs)
def do_method1(self, msg):
return msg + " through Login Server"
self._loginImplementor = LoginImplementor
self.login_server1_address = DirectAddress.Address(
self._machine_id, self._instance_id, self._login_server1_id)
self.login_server2_address = DirectAddress.Address(
self._machine_id, self._instance_id, self._login_server2_id)
self._login_server1 = LoginImplementor(
Direct=(self.login_server1_address.address, ))
self._login_server2 = LoginImplementor(
Direct=(self.login_server2_address.address, ))
def test_simple_soap_server(self):
cfg_manager = ConfigurationManager.ConfigurationManager()
cfg_manager.append_module(configuration_module)
map = CoordInfo.CoordinationMap()
login_t = SampleServerType.Login
coordinator_t = SampleServerType.Coordinator
map.add_new_machine('machine0')
map.add_new_instance('machine0', 'instance0')
map.add_new_server('machine0', 'instance0', 'server0',
coordinator_t, ())
map.add_new_server('machine0', 'instance0', 'server1', login_t, ())
# 1st: address
server_ip_address1 = SOAPAddress.Address('127.0.0.1:12349@NETWORK')
server_ip_address2 = SOAPAddress.Address('127.0.0.1:12350@NETWORK')
# 2nd: network
soap_network1 = SOAPNetwork.SOAPNetwork(server_ip_address1)
soap_network2 = SOAPNetwork.SOAPNetwork(server_ip_address2)
# 3rd: accesses
access_soap1 = Access.Access(Protocols.SOAP, AccessLevel.network,
(soap_network1, ))
access_soap2 = Access.Access(Protocols.SOAP, AccessLevel.network,
(soap_network2, ))
# 4th: appending accesses
map.append_accesses('machine0', 'instance0', 'server0',
(access_soap1, ))
map.append_accesses('machine0', 'instance0', 'server1',
(access_soap2, ))
# Generating real servers
# Coordinator must implement Protocols.Direct too
# in order to be used by the local locator
generated_coordinator = ServerSkel.factory(
cfg_manager, (Protocols.Direct, Protocols.SOAP),
coordinator_methods)
class RealCoordinatorServer(CoordinatorServer.CoordinatorServer,
generated_coordinator):
def __init__(self, cfg_manager, map, *args, **kargs):
CoordinatorServer.CoordinatorServer.__init__(
self, cfg_manager, map, *args, **kargs)
coordinator_server_address = DirectAddress.Address(
"machine0", "instance0", "server0")
s1 = RealCoordinatorServer(
cfg_manager,
map,
Direct=(coordinator_server_address.address, ),
SOAP=('', 12349))
s1.start()
generated_login = ServerSkel.factory(cfg_manager, Protocols.SOAP,
login_methods)
class RealLoginServer(generated_login):
def do_method1(self, arg):
return arg * 3
s2 = RealLoginServer(SOAP=('', 12350))
s2.start()
server_type_handler = ServerTypeHandler.ServerTypeHandler(
SampleServerType, {
'Login': login_methods,
'Coordinator': coordinator_methods,
'YetAnother': []
})
locator = ServerLocator.ServerLocator(coordinator_server_address,
server_type_handler)
login_server = locator.get_server(
coordinator_server_address.address, SampleServerType.Login,
None)
msg = "test_simple_soap_server"
answer = login_server.method1(msg)
self.assertEquals(msg * 3, answer)
def test_with_coordinator(self):
cfg_manager = ConfigurationManager.ConfigurationManager()
cfg_manager.append_module(configuration_module)
map = CoordInfo.CoordinationMap()
login_t = SampleServerType.Login
map.add_new_machine('machine0')
map.add_new_instance('machine0', 'instance0')
map.add_new_server('machine0', 'instance0', 'server0', login_t, ())
map.add_new_server('machine0', 'instance0', 'server1', login_t, ())
map.add_new_instance('machine0', 'instance1')
map.add_new_server('machine0', 'instance1', 'server0', login_t, ())
map.add_new_machine('machine1')
map.add_new_instance('machine1', 'instance0')
map.add_new_server('machine1', 'instance0', 'server0', login_t, ())
# 4 servers
# We are in machine0, instance0, server0
# They all have Direct
# 1st: address
address1 = map['machine0']['instance0']['server0'].address
address2 = map['machine0']['instance0']['server1'].address
address3 = map['machine0']['instance1']['server0'].address
address4 = map['machine1']['instance0']['server0'].address
# 2nd: network
direct_network1 = DirectNetwork.DirectNetwork(
DirectAddress.from_coord_address(address1))
direct_network2 = DirectNetwork.DirectNetwork(
DirectAddress.from_coord_address(address2))
direct_network3 = DirectNetwork.DirectNetwork(
DirectAddress.from_coord_address(address3))
direct_network4 = DirectNetwork.DirectNetwork(
DirectAddress.from_coord_address(address4))
# 3rd: accesses
access_direct1 = Access.Access(Protocols.Direct,
AccessLevel.instance,
(direct_network1, ))
access_direct2 = Access.Access(Protocols.Direct,
AccessLevel.instance,
(direct_network2, ))
access_direct3 = Access.Access(Protocols.Direct,
AccessLevel.instance,
(direct_network3, ))
access_direct4 = Access.Access(Protocols.Direct,
AccessLevel.instance,
(direct_network4, ))
# 4th: appending accesses
map.append_accesses('machine0', 'instance0', 'server0',
(access_direct1, ))
map.append_accesses('machine0', 'instance0', 'server1',
(access_direct2, ))
map.append_accesses('machine0', 'instance1', 'server0',
(access_direct3, ))
map.append_accesses('machine1', 'instance0', 'server0',
(access_direct4, ))
# They all have SOAP
# 1st: address
server_ip_address1 = SOAPAddress.Address('127.0.0.1:12345@NETWORK')
server_ip_address2 = SOAPAddress.Address('127.0.0.1:12346@NETWORK')
server_ip_address3 = SOAPAddress.Address('127.0.0.1:12347@NETWORK')
server_ip_address4 = SOAPAddress.Address('127.0.0.1:12348@NETWORK')
# 2nd: network
soap_network1 = SOAPNetwork.SOAPNetwork(server_ip_address1)
soap_network2 = SOAPNetwork.SOAPNetwork(server_ip_address2)
soap_network3 = SOAPNetwork.SOAPNetwork(server_ip_address3)
soap_network4 = SOAPNetwork.SOAPNetwork(server_ip_address4)
# 3rd: accesses
access_soap1 = Access.Access(Protocols.SOAP, AccessLevel.network,
(soap_network1, ))
access_soap2 = Access.Access(Protocols.SOAP, AccessLevel.network,
(soap_network2, ))
access_soap3 = Access.Access(Protocols.SOAP, AccessLevel.network,
(soap_network3, ))
access_soap4 = Access.Access(Protocols.SOAP, AccessLevel.network,
(soap_network4, ))
# 4th: appending accesses
map.append_accesses('machine0', 'instance0', 'server0',
(access_soap1, ))
map.append_accesses('machine0', 'instance0', 'server1',
(access_soap2, ))
map.append_accesses('machine0', 'instance1', 'server0',
(access_soap3, ))
map.append_accesses('machine1', 'instance0', 'server0',
(access_soap4, ))
direct_coordinator = ServerSkel.factory(
cfg_manager, (Protocols.Direct, Protocols.SOAP),
coordinator_methods)
class YetAnother(CoordinatorServer.CoordinatorServer,
direct_coordinator):
def __init__(self, cfg_manager, map, *args, **kargs):
CoordinatorServer.CoordinatorServer.__init__(
self, cfg_manager, map, *args, **kargs)
direct_login = ServerSkel.factory(
cfg_manager, (Protocols.Direct, Protocols.SOAP), login_methods)
coordinator_server_address = DirectAddress.Address(
"machine0", "instance0", "server0")
s1 = YetAnother(cfg_manager,
map,
Direct=(coordinator_server_address.address, ),
SOAP=('', 12345))
s1.start()
class YetAnother2(direct_login):
def do_method1(self, arg):
return arg * 3
s2 = YetAnother2(Direct=(address2.address, ), SOAP=('', 12346))
s2.start()
server_type_handler = ServerTypeHandler.ServerTypeHandler(
SampleServerType, {
'Login': login_methods,
'Coordinator': coordinator_methods,
'YetAnother': []
})
locator = ServerLocator.ServerLocator(coordinator_server_address,
server_type_handler)
login_server = locator.get_server(
coordinator_server_address.address, SampleServerType.Login,
None)
full_name = '%s.%s' % (login_server.__class__.__module__,
login_server.__class__.__name__)
self.assertEquals(
'voodoo.gen.protocols.Direct.ClientDirect.ClientDirect',
full_name)
msg = "hello"
answer = login_server.method1(msg)
self.assertEquals(msg * 3, answer)
other_login_server = locator.get_server(
coordinator_server_address.address, SampleServerType.Login,
None)
# It will ask for it from the cache
self.assertEquals(login_server, other_login_server)
# Let's say that the login server is broken
locator.inform_server_not_working(login_server,
SampleServerType.Login, None)
old_test_me = YetAnother2.do_test_me
def wrong_test_me(self, arg):
YetAnother2.do_test_me = old_test_me
return arg * 2
YetAnother2.do_test_me = wrong_test_me
yet_another_login_server = locator.get_server(
coordinator_server_address.address, SampleServerType.Login,
None)
self.assertNotEquals(login_server, yet_another_login_server)
full_name = '%s.%s' % (
yet_another_login_server.__class__.__module__,
yet_another_login_server.__class__.__name__)
self.assertEquals(
'voodoo.gen.protocols.SOAP.ClientSOAP.ClientSOAP', full_name)
answer = yet_another_login_server.method1(msg)
self.assertEquals(msg * 3, answer)
def wrong_test_me_forever(self, arg):
return arg * 2
YetAnother2.do_test_me = wrong_test_me_forever
locator.inform_server_not_working(yet_another_login_server,
SampleServerType.Login, None)
return # TODO:
# YetAnother2 doesn't work anymore, and the other two ports are not going to work
self.assertRaises(LocatorErrors.NoServerFoundError,
locator.get_server,
coordinator_server_address.address,
SampleServerType.Login, None)
