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 )