def test_soap_create_client(self):
message2 = self.message2
cfg_manager = ConfigurationManager.ConfigurationManager()
cfg_manager.append_module(configuration_module)
soap_server_class = ServerSkel.factory(cfg_manager, Protocols.SOAP,
self.methods)
class SoapServerClass(soap_server_class):
def do_say_hello(self, msg):
return msg + message2
soap_server_instance = SoapServerClass(SOAP=('', self.port))
soap_server_instance.start()
soap_addr = SOAPAddress.Address(self.host + ':' + str(self.port) +
'@NetworkA')
soap_client = soap_addr.create_client(self.methods)
self.assertEquals(soap_client.say_hello(self.message1),
self.message1 + message2)
soap_server_instance.stop()
soap_addr = SOAPAddress.Address(self.host + ':' + str(self.port) +
'@NetworkA')
def generate_laboratory_server(self, cfg_manager, protocols):
generated_laboratory_server = ServerSkel.factory(
cfg_manager,
protocols,
weblab_exported_methods.Laboratory
)
locator = self.generate_locator()
class RealLaboratoryServer(LaboratoryServer.LaboratoryServer,generated_laboratory_server):
def __init__(self, coord_address, locator, cfg_manager, *args,**kargs):
LaboratoryServer.LaboratoryServer.__init__(
self,
coord_address,
locator,
cfg_manager,
*args,
**kargs
)
real_laboratory_server = RealLaboratoryServer(
self.map['WL_MACHINE1']['WL_SERVER1']['laboratory1'].address,
locator,
cfg_manager,
Direct = (self.map['WL_MACHINE1']['WL_SERVER1']['laboratory1'].address.address,),
SOAP = ('',10129)
)
real_laboratory_server.start()
laboratory_client = locator.get_server(ServerType.Laboratory, None)
return laboratory_client, real_laboratory_server
def generate_login_server(self, protocols, cfg_manager):
login_coord_address = CoordAddress.CoordAddress.translate_address(
"login1:WL_SERVER1@WL_MACHINE1")
locator = self.generate_locator()
generated_login_server = ServerSkel.factory(
self.generate_configuration_server(), protocols,
weblab_exported_methods.Login)
class RealLoginServer(LoginServer.LoginServer, generated_login_server):
def __init__(self, coord_address, locator, cfg_manager, *args,
**kargs):
LoginServer.LoginServer.__init__(self, coord_address, locator,
cfg_manager, *args, **kargs)
real_login_server = RealLoginServer(
login_coord_address,
locator,
cfg_manager,
Direct=(login_coord_address.address, ),
SOAP=('', 10125))
real_login_server.start()
login_client = locator.get_server(ServerType.Login, None)
return login_client, real_login_server
def test_xmlrpc_create_client(self):
message2 = self.message2
cfg_manager = ConfigurationManager.ConfigurationManager()
cfg_manager.append_module(configuration_module)
xmlrpc_server_class = ServerSkel.factory(cfg_manager, Protocols.XMLRPC,
self.methods)
class XmlRpcServerClass(xmlrpc_server_class):
def do_say_hello(self, msg):
return msg + message2
xmlrpc_server_instance = XmlRpcServerClass(XMLRPC=('', self.port))
xmlrpc_server_instance.start()
xmlrpc_addr = XMLRPCAddress.Address(self.host + ':' + str(self.port) +
'@NetworkA')
xmlrpc_client = xmlrpc_addr.create_client(self.methods)
self.assertEquals(xmlrpc_client.say_hello(self.message1),
self.message1 + message2)
xmlrpc_server_instance.stop()
xmlrpc_addr = XMLRPCAddress.Address(self.host + ':' + str(self.port) +
'@NetworkA')
def generate_core_server(self, cfg_manager, protocols):
ups_coord_address = CoordAddress.CoordAddress.translate_address(
"ups1:WL_SERVER1@WL_MACHINE1")
locator = self.generate_locator()
generated_ups = ServerSkel.factory(
cfg_manager, protocols, weblab_exported_methods.UserProcessing)
class RealUserProcessingServer(
UserProcessingServer.UserProcessingServer, generated_ups):
def __init__(self, coord_address, locator, cfg_manager, *args,
**kargs):
UserProcessingServer.UserProcessingServer.__init__(
self, coord_address, locator, cfg_manager, *args, **kargs)
coordinator = coordinator_create(SQLALCHEMY, self.locator,
self.cfg_manager)
coordinator._clean()
coordinator.stop()
real_core_server = RealUserProcessingServer(
ups_coord_address,
locator,
cfg_manager,
Direct=(ups_coord_address.address, ),
SOAP=('', 10126))
real_core_server.start()
core_client = locator.get_server(ServerType.UserProcessing, None)
return core_client, real_core_server
def test_xmlrpc_create_client(self):
message2 = self.message2
cfg_manager= ConfigurationManager.ConfigurationManager()
cfg_manager.append_module(configuration_module)
xmlrpc_server_class = ServerSkel.factory(cfg_manager,Protocols.XMLRPC,self.methods)
class XmlRpcServerClass(xmlrpc_server_class):
def do_say_hello(self,msg):
return msg + message2
xmlrpc_server_instance = XmlRpcServerClass(
XMLRPC = ('',self.port)
)
xmlrpc_server_instance.start()
xmlrpc_addr = XMLRPCAddress.Address(
self.host + ':' + str(self.port) + '@NetworkA'
)
xmlrpc_client = xmlrpc_addr.create_client(self.methods)
self.assertEquals(
xmlrpc_client.say_hello(self.message1),
self.message1 + message2
)
xmlrpc_server_instance.stop()
xmlrpc_addr = XMLRPCAddress.Address(
self.host + ':' + str(self.port) + '@NetworkA'
)
def _create_server(self, global_config, machine_name, instance_name,
server_name, locator, cfg_manager):
server_config = global_config.machines[machine_name].instances[
instance_name].servers[server_name]
protocols = [
getattr(Protocols, protocol.name)
for protocol in server_config.protocols
]
generated_server = ServerSkel.factory(cfg_manager, protocols,
server_config.methods)
class RealServer(server_config.implementation, generated_server):
def __init__(self, coord_address, locator, cfg_manager, *args,
**kargs):
server_config.implementation.__init__(self, coord_address,
locator, cfg_manager,
*args, **kargs)
RealServer.__name__ = 'Server of %s' % server_config.implementation
coord_address = CoordAddress.CoordAddress(machine_name, instance_name,
server_name)
protocol_args = {}
for protocol in server_config.protocols:
if isinstance(protocol.name, unicode):
protocol_name = str(protocol.name)
else:
protocol_name = protocol.name
protocol_args[protocol_name] = protocol.filled_creation[1]
real_server = RealServer(coord_address, locator, cfg_manager,
**protocol_args)
real_server.start()
return real_server
def _create_coordinator_server(self, global_config, machine_name, instance_name):
map_builder = CoordinatorMapBuilder.CoordinatorMapBuilder()
map = map_builder.build(global_config)
coordinator_server_name = self._generate_coordinator_server_name(machine_name, instance_name)
any_server = global_config.machines[machine_name].instances[instance_name].servers.values()[0]
server_type = getattr(any_server.server_type_module, "Coordinator")
map.add_new_server(machine_name, instance_name, coordinator_server_name, server_type, (), ())
coordinator_coord_address = map[machine_name][instance_name][coordinator_server_name].address
coordinator_network = DirectNetwork.DirectNetwork(DirectAddress.from_coord_address(coordinator_coord_address))
coordinator_access = Access.Access(Protocols.Direct, AccessLevel.instance, (coordinator_network,))
map.append_accesses(machine_name, instance_name, coordinator_server_name, (coordinator_access,))
protocols = (Protocols.Direct,)
cfg_manager = self._create_config_manager_for_instance(global_config, machine_name, instance_name)
generated_coordinator = ServerSkel.factory(cfg_manager, protocols, voodoo_exported_methods.coordinator)
class RealCoordinatorServer(CoordinatorServer.CoordinatorServer, generated_coordinator):
def __init__(self, cfg_manager, map, *args, **kargs):
CoordinatorServer.CoordinatorServer.__init__(self, cfg_manager, map, *args, **kargs)
real_coordinator_server = RealCoordinatorServer(cfg_manager, map, Direct=(coordinator_coord_address.address,))
real_coordinator_server.start()
return real_coordinator_server
def generate_login_server(self, protocols, cfg_manager):
login_coord_address = CoordAddress.CoordAddress.translate_address("login1:WL_SERVER1@WL_MACHINE1")
locator = self.generate_locator()
generated_login_server = ServerSkel.factory(
self.generate_configuration_server(),
protocols,
weblab_exported_methods.Login
)
class RealLoginServer(LoginServer.LoginServer,generated_login_server):
def __init__(self, coord_address, locator, cfg_manager, *args,**kargs):
LoginServer.LoginServer.__init__(self, coord_address, locator, cfg_manager, *args, **kargs)
real_login_server = RealLoginServer(
login_coord_address,
locator,
cfg_manager,
Direct = (login_coord_address.address,),
SOAP = ('',10125)
)
real_login_server.start()
login_client = locator.get_server(ServerType.Login, None)
return login_client, real_login_server
def generate_coordinator_server(self, protocol, cfg_manager):
map = self.gen_coordination_map(protocol)
protocols = protocol
if protocol[0] != Protocols.Direct:
protocols += (Protocols.Direct,)
generated_coordinator = ServerSkel.factory(
cfg_manager,
protocols,
voodoo_exported_methods.coordinator
)
class RealCoordinatorServer(CoordinatorServer.CoordinatorServer,generated_coordinator):
def __init__(self,cfg_manager,map,*args,**kargs):
CoordinatorServer.CoordinatorServer.__init__(self,cfg_manager,map,*args,**kargs)
real_coordinator_server = RealCoordinatorServer(
cfg_manager,
map,
Direct = (map['WL_MACHINE1']['WL_SERVER1']['coordinator1'].address.address,),
SOAP = ('',10127)
)
real_coordinator_server.start()
self.map = map
return real_coordinator_server
def generate_fake_experiment(self, cfg_manager, fake_xilinx_impact,
fake_serial_port, number, experiment_name,
experiment_category_name, protocols):
generated_experiment = ServerSkel.factory(
cfg_manager, protocols, weblab_exported_methods.Experiment)
locator = self.generate_locator()
class RealUdXilinxExperiment(FakeUdXilinxExperiment,
generated_experiment):
def __init__(self, coord_address, locator, cfg_manager,
fake_xilinx_impact, fake_serial_port, *args, **kargs):
FakeUdXilinxExperiment.__init__(self, coord_address, locator,
cfg_manager,
fake_xilinx_impact,
fake_serial_port, *args,
**kargs)
real_experiment = RealUdXilinxExperiment(
None,
None,
cfg_manager,
fake_xilinx_impact,
fake_serial_port,
Direct=(self.map['WL_MACHINE1']['WL_SERVER1'][
'experiment' + number].address.address, ),
SOAP=('', 10131 + (int(number) - 1)))
real_experiment.start()
def on_finish():
experiment_client = locator.get_server(
ServerType.Experiment,
experiment_name + '@' + experiment_category_name)
return experiment_client, real_experiment
return on_finish
def test_soap_create_client(self):
message2 = self.message2
cfg_manager= ConfigurationManager.ConfigurationManager()
cfg_manager.append_module(configuration_module)
soap_server_class = ServerSkel.factory(cfg_manager, Protocols.SOAP,self.methods)
class SoapServerClass(soap_server_class):
def do_say_hello(self,msg):
return msg + message2
soap_server_instance = SoapServerClass(
SOAP = ('',self.port)
)
soap_server_instance.start()
soap_addr = SOAPAddress.Address(
self.host + ':' + str(self.port) + '@NetworkA'
)
soap_client = soap_addr.create_client(self.methods)
self.assertEquals(
soap_client.say_hello(self.message1),
self.message1 + message2
)
soap_server_instance.stop()
soap_addr = SOAPAddress.Address(
self.host + ':' + str(self.port) + '@NetworkA'
)
def generate_coordinator_server(self, protocol, cfg_manager):
map = self.gen_coordination_map(protocol)
protocols = protocol
if protocol[0] != Protocols.Direct:
protocols += (Protocols.Direct, )
generated_coordinator = ServerSkel.factory(
cfg_manager, protocols, voodoo_exported_methods.coordinator)
class RealCoordinatorServer(CoordinatorServer.CoordinatorServer,
generated_coordinator):
def __init__(self, cfg_manager, map, *args, **kargs):
CoordinatorServer.CoordinatorServer.__init__(
self, cfg_manager, map, *args, **kargs)
real_coordinator_server = RealCoordinatorServer(
cfg_manager,
map,
Direct=(map['WL_MACHINE1']['WL_SERVER1']
['coordinator1'].address.address, ),
SOAP=('', 10127))
real_coordinator_server.start()
self.map = map
return real_coordinator_server
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_laboratory_server(self, cfg_manager, protocols):
generated_laboratory_server = ServerSkel.factory(
cfg_manager,
protocols,
weblab_exported_methods.Laboratory
)
locator = self.generate_locator()
class RealLaboratoryServer(LaboratoryServer.LaboratoryServer,generated_laboratory_server):
def __init__(self, coord_address, locator, cfg_manager, *args,**kargs):
LaboratoryServer.LaboratoryServer.__init__(
self,
coord_address,
locator,
cfg_manager,
*args,
**kargs
)
real_laboratory_server = RealLaboratoryServer(
self.map['WL_MACHINE1']['WL_SERVER1']['laboratory1'].address,
locator,
cfg_manager,
Direct = (self.map['WL_MACHINE1']['WL_SERVER1']['laboratory1'].address.address,),
SOAP = ('',10029)
)
real_laboratory_server.start()
laboratory_client = locator.get_server(ServerType.Laboratory, None)
return laboratory_client, real_laboratory_server
def _create_coordinator_server(self, global_config, machine_name,
instance_name):
map_builder = CoordinatorMapBuilder.CoordinatorMapBuilder()
map = map_builder.build(global_config)
coordinator_server_name = self._generate_coordinator_server_name(
machine_name, instance_name)
any_server = global_config.machines[machine_name].instances[
instance_name].servers.values()[0]
server_type = getattr(any_server.server_type_module, 'Coordinator')
map.add_new_server(machine_name, instance_name,
coordinator_server_name, server_type, (), ())
coordinator_coord_address = map[machine_name][instance_name][
coordinator_server_name].address
coordinator_network = DirectNetwork.DirectNetwork(
DirectAddress.from_coord_address(coordinator_coord_address))
coordinator_access = Access.Access(Protocols.Direct,
AccessLevel.instance,
(coordinator_network, ))
map.append_accesses(machine_name, instance_name,
coordinator_server_name, (coordinator_access, ))
protocols = (Protocols.Direct, )
cfg_manager = self._create_config_manager_for_instance(
global_config, machine_name, instance_name)
generated_coordinator = ServerSkel.factory(
cfg_manager, protocols, voodoo_exported_methods.coordinator)
class RealCoordinatorServer(CoordinatorServer.CoordinatorServer,
generated_coordinator):
def __init__(self, cfg_manager, map, *args, **kargs):
CoordinatorServer.CoordinatorServer.__init__(
self, cfg_manager, map, *args, **kargs)
real_coordinator_server = RealCoordinatorServer(
cfg_manager,
map,
Direct=(coordinator_coord_address.address, ),
)
real_coordinator_server.start()
return real_coordinator_server
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_fake_experiment(self, cfg_manager, fake_xilinx_impact, fake_serial_port, number, experiment_name, experiment_category_name, protocols):
generated_experiment = ServerSkel.factory(
cfg_manager,
protocols,
weblab_exported_methods.Experiment
)
locator = self.generate_locator()
class RealUdXilinxExperiment(FakeUdXilinxExperiment,generated_experiment):
def __init__(self, coord_address, locator, cfg_manager, fake_xilinx_impact, fake_serial_port, *args,**kargs):
FakeUdXilinxExperiment.__init__(
self,
coord_address,
locator,
cfg_manager,
fake_xilinx_impact,
fake_serial_port,
*args,
**kargs
)
real_experiment = RealUdXilinxExperiment(
None,
None,
cfg_manager,
fake_xilinx_impact,
fake_serial_port,
Direct = ( self.map['WL_MACHINE1']['WL_SERVER1']['experiment' + number].address.address,),
SOAP = ('',10131 + (int(number)-1))
)
real_experiment.start()
def on_finish():
experiment_client = locator.get_server(
ServerType.Experiment,
experiment_name + '@' + experiment_category_name
)
return experiment_client, real_experiment
return on_finish
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 _create_server(self, global_config, machine_name, instance_name, server_name, locator, cfg_manager):
server_config = global_config.machines[machine_name].instances[instance_name].servers[server_name]
protocols = [ getattr(Protocols,protocol.name) for protocol in server_config.protocols ]
generated_server = ServerSkel.factory(
cfg_manager,
protocols,
server_config.methods
)
class RealServer(server_config.implementation, generated_server):
def __init__(self, coord_address, locator, cfg_manager,*args,**kargs):
server_config.implementation.__init__(self, coord_address, locator, cfg_manager, *args, **kargs)
RealServer.__name__ = 'Server of %s' % server_config.implementation
coord_address = CoordAddress.CoordAddress(
machine_name,
instance_name,
server_name
)
protocol_args = {}
for protocol in server_config.protocols:
if isinstance(protocol.name, unicode):
protocol_name = str(protocol.name)
else:
protocol_name = protocol.name
protocol_args[protocol_name] = protocol.filled_creation[1]
real_server = RealServer(
coord_address,
locator,
cfg_manager,
**protocol_args
)
real_server.start()
return real_server
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 generate_core_server(self, cfg_manager, protocols):
ups_coord_address = CoordAddress.CoordAddress.translate_address("ups1:WL_SERVER1@WL_MACHINE1")
locator = self.generate_locator()
generated_ups = ServerSkel.factory(
cfg_manager,
protocols,
weblab_exported_methods.UserProcessing
)
class RealUserProcessingServer(UserProcessingServer.UserProcessingServer,generated_ups):
def __init__(self, coord_address, locator, cfg_manager, *args,**kargs):
UserProcessingServer.UserProcessingServer.__init__(
self,
coord_address,
locator,
cfg_manager,
*args,
**kargs
)
coordinator = coordinator_create(SQLALCHEMY, self.locator, self.cfg_manager)
coordinator._clean()
coordinator.stop()
real_core_server = RealUserProcessingServer(
ups_coord_address,
locator,
cfg_manager,
Direct = (ups_coord_address.address,),
SOAP = ('',10126)
)
real_core_server.start()
core_client = locator.get_server(ServerType.UserProcessing, None)
return core_client, real_core_server
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
)
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 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)
class Server(ServerSkel.factory(cfg_manager, protocol,methods)):
def do_method2(self,whatever):
return sentence + whatever
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)
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
)
