def test_nested_flatten_with_multiple_values_2(self): class CM(ComplexModel): i = Integer s = String class CCM(ComplexModel): c = CM.customize(max_occurs=2) i = Integer s = String class SomeService(ServiceBase): @srpc(CCM, _returns=String) def some_call(ccm): return repr(ccm) app = Application([SomeService], 'tns', HttpRpc(), HttpRpc(), Wsdl11()) server = WsgiApplication(app) initial_ctx = WsgiMethodContext(server, { 'QUERY_STRING': 'ccm_i=1&ccm_s=s&ccm_c_i=3&ccm_c_s=cs', 'PATH_INFO': '/some_call', 'REQUEST_METHOD': 'GET', }, 'some-content-type') ctx, = server.generate_contexts(initial_ctx) try: server.get_in_object(ctx) except: pass else: raise Exception("Must fail with: Exception: HttpRpc deserializer " "does not support non-primitives with max_occurs > 1")
def test_multiple_return(self): class SomeNotSoComplexModel(ComplexModel): s = String class SomeService(ServiceBase): @srpc(_returns=[Integer, String]) def some_call(): return 1, 's' app = Application([SomeService], 'tns', HttpRpc(), HttpRpc(), Wsdl11()) server = WsgiApplication(app) initial_ctx = WsgiMethodContext(server, { 'QUERY_STRING': '', 'PATH_INFO': '/some_call', 'QUERY_STRING': '?s=a', 'REQUEST_METHOD': 'GET', }, 'some-content-type') try: ctx, = server.generate_contexts(initial_ctx) server.get_in_object(ctx) server.get_out_object(ctx) server.get_out_string(ctx) except ValueError: pass else: raise Exception("Must fail with: HttpRpc does not support complex " "return types.")
def test_primitive_only(self): class SomeComplexModel(ComplexModel): i = Integer s = String class SomeService(ServiceBase): @srpc(SomeComplexModel, _returns=SomeComplexModel) def some_call(scm): return SomeComplexModel(i=5, s='5x') app = Application([SomeService], 'tns', HttpRpc(), HttpRpc(), Wsdl11()) server = WsgiApplication(app) initial_ctx = WsgiMethodContext(server, { 'QUERY_STRING': '', 'PATH_INFO': '/some_call', 'REQUEST_METHOD': 'GET', }, 'some-content-type') ctx, = server.generate_contexts(initial_ctx) server.get_in_object(ctx) server.get_out_object(ctx) try: server.get_out_string(ctx) except: pass else: raise Exception("Must fail with: HttpRpc does not support complex " "return types.")
def test_complex(self): class CM(ComplexModel): i = Integer s = String class CCM(ComplexModel): c = CM i = Integer s = String class SomeService(ServiceBase): @srpc(CCM, _returns=CCM) def some_call(ccm): return CCM(c=ccm.c, i=ccm.i, s=ccm.s) app = Application([SomeService], 'tns', HttpRpc(), HttpRpc(), Wsdl11()) server = WsgiApplication(app) initial_ctx = WsgiMethodContext(server, { 'QUERY_STRING': '', 'PATH_INFO': '/some_call', 'REQUEST_METHOD': 'GET', }, 'some-content-type') ctx, = server.generate_contexts(initial_ctx) server.get_in_object(ctx) server.get_out_object(ctx) server.get_out_string(ctx)
def main(argv): observer = log.PythonLoggingObserver('twisted') log.startLoggingWithObserver(observer.emit, setStdout=False) wsgi_application = WsgiApplication(soap_application) return run_twisted([(wsgi_application, url)], port)
def setup_services(self, applications): """Setting up the service that should be run by twisted. This is here an rpclib service in the standard WSGI format.""" if type(applications) not in (list, tuple, dict): applications = [applications] self.service = rpclib.application.Application( applications, tns=self.namespace, interface=Wsdl11(), in_protocol=Soap11(validator='lxml'), out_protocol=Soap11()) self.wsgi_application = WsgiApplication(self.service)
def wsgi_soap11_application(services, tns='rpclib.simple.soap', validator=None): """Wraps `services` argument inside a WsgiApplication that uses Wsdl 1.1 as interface document and Soap 1.1 and both input and output protocols. """ application = Application(services, tns, interface=Wsdl11(), in_protocol=Soap11(validator=validator), out_protocol=Soap11()) return WsgiApplication(application)
def test_string_array(self): class SomeService(ServiceBase): @srpc(String(max_occurs='unbounded'), _returns=Array(String)) def some_call(s): return s app = Application([SomeService], 'tns', HttpRpc(), HtmlTable(), Wsdl11()) server = WsgiApplication(app) initial_ctx = WsgiMethodContext(server, { 'QUERY_STRING': 's=1&s=2', 'PATH_INFO': '/some_call', 'REQUEST_METHOD': 'GET', }, 'some-content-type') ctx, = server.generate_contexts(initial_ctx) server.get_in_object(ctx) server.get_out_object(ctx) server.get_out_string(ctx) assert ''.join(ctx.out_string) == '<table class="some_callResponse"><tr><th>string</th></tr><tr><td>1</td></tr><tr><td>2</td></tr></table>'
def test_multiple(self): class SomeService(ServiceBase): @srpc(String(max_occurs='unbounded'), _returns=String) def some_call(s): return '\n'.join(s) app = Application([SomeService], 'tns', HttpRpc(), HttpRpc(), Wsdl11()) server = WsgiApplication(app) initial_ctx = WsgiMethodContext(server, { 'QUERY_STRING': 's=1&s=2', 'PATH_INFO': '/some_call', 'REQUEST_METHOD': 'GET', }, 'some-content-type') ctx, = server.generate_contexts(initial_ctx) server.get_in_object(ctx) server.get_out_object(ctx) server.get_out_string(ctx) assert ctx.out_string == ['1\n2']
def __call__(self, request): django_response = HttpResponse() def start_response(status, headers): status, reason = status.split(' ', 1) django_response.status_code = int(status) for header, value in headers: django_response[header] = value environ = request.META.copy() environ['wsgi.input'] = request environ['wsgi.multithread'] = False response = WsgiApplication.__call__(self, environ, start_response) django_response.content = "\n".join(response) return django_response
def test_simple(self): class SomeService(ServiceBase): @srpc(String, _returns=String) def some_call(s): return s app = Application([SomeService], 'tns', HttpRpc(), HtmlMicroFormat(), Wsdl11()) server = WsgiApplication(app) initial_ctx = WsgiMethodContext(server, { 'QUERY_STRING': 's=s', 'PATH_INFO': '/some_call', 'REQUEST_METHOD': 'GET', }, 'some-content-type') ctx, = server.generate_contexts(initial_ctx) assert ctx.in_error is None server.get_in_object(ctx) server.get_out_object(ctx) server.get_out_string(ctx) assert ''.join(ctx.out_string) == '<div class="some_callResponse"><div class="some_callResult">s</div></div>'
def test_multiple_return(self): class SomeNotSoComplexModel(ComplexModel): s = String class SomeService(ServiceBase): @srpc(_returns=[Integer, String]) def some_call(): return 1, 's' app = Application([SomeService], 'tns', HttpRpc(), HtmlMicroFormat(), Wsdl11()) server = WsgiApplication(app) initial_ctx = WsgiMethodContext(server, { 'QUERY_STRING': '', 'PATH_INFO': '/some_call', 'REQUEST_METHOD': 'GET', }, 'some-content-type') ctx, = server.generate_contexts(initial_ctx) server.get_in_object(ctx) server.get_out_object(ctx) server.get_out_string(ctx) assert ''.join(ctx.out_string) == '<div class="some_callResponse"><div class="some_callResult0">1</div><div class="some_callResult1">s</div></div>'
def test_nested_flatten(self): class CM(ComplexModel): i = Integer s = String class CCM(ComplexModel): c = CM i = Integer s = String class SomeService(ServiceBase): @srpc(CCM, _returns=String) def some_call(ccm): return repr(ccm) app = Application([SomeService], 'tns', HttpRpc(), HttpRpc(), Wsdl11()) server = WsgiApplication(app) initial_ctx = WsgiMethodContext(server, { 'QUERY_STRING': 'ccm_i=1&ccm_s=s&ccm_c_i=3&ccm_c_s=cs', 'PATH_INFO': '/some_call', 'REQUEST_METHOD': 'GET', }, 'some-content-type') ctx, = server.generate_contexts(initial_ctx) server.get_in_object(ctx) assert ctx.in_error is None server.get_out_object(ctx) assert ctx.out_error is None server.get_out_string(ctx) print ctx.out_string assert ctx.out_string == ["CCM(i=1, c=CM(i=3, s='cs'), s='s')"]
def setup_services(self, applications): """Setting up the service that should be run by twisted. This is here an rpclib service in the standard WSGI format.""" if type(applications) not in (list, tuple, dict): applications = [applications] # Set the encoding for SOAP data, converting it from unicode to some # str encoding. We could instead use the Unicode classes, but Cerebrum # doesn't support unicode natively quite yet. String.Attributes.encoding = 'latin1' # Ignore unencodable characters # The following function does the same as String.from_string, except # that it supplies 'ignore' as an argument to encode() from rpclib.model import nillable_string @classmethod @nillable_string def from_string(cls, value): retval = value if isinstance(value, unicode): if cls.Attributes.encoding is None: raise Exception("You need to define an encoding to " "convert the incoming unicode values to.") else: retval = value.encode(cls.Attributes.encoding, 'ignore') return retval String.from_string = from_string self.service = rpclib.application.Application( applications, tns=self.namespace, interface=Wsdl11(), in_protocol=Soap11(validator='lxml'), out_protocol=Soap11()) self.wsgi_application = WsgiApplication(self.service)
if "session-id" not in cookie: raise UnauthenticatedError() session_cookie = cookie["session-id"].value session_id = tuple(base64.urlsafe_b64decode(session_cookie).split("\0", 1)) if not session_id in session_db: raise AuthenticationError(session_id[0]) ctx.udc = session_id[0] # user name UserService.event_manager.add_listener('method_call', _on_method_call) if __name__=='__main__': from rpclib.util.wsgi_wrapper import run_twisted logging.basicConfig(level=logging.DEBUG) logging.getLogger('rpclib.protocol.xml').setLevel(logging.DEBUG) logging.getLogger('twisted').setLevel(logging.DEBUG) application = Application([UserService], tns='rpclib.examples.authentication', interface=Wsdl11(), in_protocol=Soap11(validator='lxml'), out_protocol=Soap11() ) twisted_apps = [ (WsgiApplication(application), 'app'), ] sys.exit(run_twisted(twisted_apps, 7789))
import logging logging.basicConfig(level=logging.DEBUG) logger = logging.getLogger('rpclib.protocol.xml') logger.setLevel(logging.DEBUG) from rpclib.application import Application from rpclib.test.interop.server._service import services from rpclib.protocol.csv import OutCsv from rpclib.protocol.http import HttpRpc from rpclib.interface.wsdl import Wsdl11 httprpc_csv_application = Application( services, 'rpclib.test.interop.server.httprpc.csv', Wsdl11(), HttpRpc(), OutCsv()) from rpclib.server.wsgi import WsgiApplication if __name__ == '__main__': try: from wsgiref.simple_server import make_server from wsgiref.validate import validator wsgi_application = WsgiApplication(httprpc_csv_application) server = make_server('0.0.0.0', 9755, validator(wsgi_application)) logger.info('Starting interop server at %s:%s.' % ('0.0.0.0', 9755)) logger.info('WSDL is at: /?wsdl') server.serve_forever() except ImportError: print("Error: example server code requires Python >= 2.5")
# We are going to use the ubiquitious Http protocol as a transport, using a Wsgi-compliant http server. # This example uses Python’s stock simple wsgi web server. Rpclib has been tested with several other web servers. # Any WSGI-compliant server should work. # This is the required import: if __name__ == '__main__': try: from wsgiref.simple_server import make_server except ImportError: print "Error: example server code requires Python >= 2.5" # Here, we configure the python logger to show debugging output. We have to specifically enable the debug output from the soap handler. # That’s because the xml formatting code is run only when explicitly enabled for performance reasons logging.basicConfig(level=logging.DEBUG) logging.getLogger('rpclib.protocol.xml').setLevel(logging.DEBUG) # We glue the service definition, interface document and input and output protocols under the targetNamespace ‘opinionAnalysys.api.analyseOpinion.soap’: application = Application([opinionAnalisys_Service], 'opinionAnalysys.api.analyseOpinion.soap', interface=Wsdl11(), in_protocol=Soap11(), out_protocol=Soap11()) server = make_server( '127.0.0.1', 7789, WsgiApplication(application) ) # We then wrap the rpclib application with its wsgi wrapper: print "listening to http://127.0.0.1:7789. wsdl is at: http://localhost:7789/?wsdl" server.serve_forever()
freebusy = [] for fb_request in fb_requests: calendar_folder = fb_request["folder"] if calendar_folder is None: log.warn("no calendar folder found for '%s'" % user_email) fb_response \ = ExchangeService._freebusy_lookup_error_response() else: fb_response \ = ExchangeService._freebusy_response(calendar_folder, timezone, freebusy_view_options) freebusy.append(fb_response) else: freebusy = None if suggestions_view_options is not None: suggestions \ = ExchangeService._suggestions_response(timezone, suggestions_view_options) else: suggestions = None return (freebusy, suggestions) EwsApp = Application([ExchangeService], EWS_M_NS, name="ExchangeApplication", interface=Wsdl11(), in_protocol=Soap11(), out_protocol=Soap11()) AsController = WsgiApplication(EwsApp)
def test_rpc(self): import sqlalchemy from sqlalchemy import sql class KeyValuePair(TableSerializer, self.DeclarativeBase): __tablename__ = 'key_value_store' __namespace__ = 'punk' key = Column(sqlalchemy.String(100), nullable=False, primary_key=True) value = Column(sqlalchemy.String, nullable=False) self.metadata.create_all(self.engine) import hashlib session = self.Session() for i in range(1, 10): key = str(i) m = hashlib.md5() m.update(key) value = m.hexdigest() session.add(KeyValuePair(key=key, value=value)) session.commit() from rpclib.service import ServiceBase from rpclib.model.complex import Array from rpclib.model.primitive import String class Service(ServiceBase): @rpc(String(max_occurs='unbounded'), _returns=Array(KeyValuePair), _in_variable_names={ 'keys': 'key' } ) def get_values(ctx, keys): session = self.Session() return session.query(KeyValuePair).filter(sql.and_( KeyValuePair.key.in_(keys) )).order_by(KeyValuePair.key) application = Application([Service], interface=Wsdl11(), in_protocol=HttpRpc(), out_protocol=Soap11(), name='Service', tns='tns' ) server = WsgiApplication(application) initial_ctx = WsgiMethodContext(server, { 'REQUEST_METHOD': 'GET', 'QUERY_STRING': 'key=1&key=2&key=3', 'PATH_INFO': '/get_values', }, 'some-content-type') ctx, = server.generate_contexts(initial_ctx) server.get_in_object(ctx) server.get_out_object(ctx) server.get_out_string(ctx) i = 0 for e in ctx.out_document[0][0][0]: i+=1 key = str(i) m = hashlib.md5() m.update(key) value = m.hexdigest() _key = e.find('{%s}key' % KeyValuePair.get_namespace()) _value = e.find('{%s}value' % KeyValuePair.get_namespace()) print((_key, _key.text)) print((_value, _value.text)) self.assertEquals(_key.text, key) self.assertEquals(_value.text, value)
import logging logging.basicConfig(level=logging.DEBUG) logger = logging.getLogger('rpclib.protocol.xml') logger.setLevel(logging.DEBUG) from rpclib.application import Application from rpclib.test.interop.server._service import services from rpclib.protocol.soap import Soap11 from rpclib.protocol.http import HttpRpc from rpclib.interface.wsdl import Wsdl11 httprpc_soap_application = Application(services, 'rpclib.test.interop.server.httprpc.soap', Wsdl11(), HttpRpc(), Soap11()) from rpclib.server.wsgi import WsgiApplication if __name__ == '__main__': try: from wsgiref.simple_server import make_server from wsgiref.validate import validator wsgi_application = WsgiApplication(httprpc_soap_application) server = make_server('0.0.0.0', 9756, validator(wsgi_application)) logger.info('Starting interop server at %s:%s.' % ('0.0.0.0', 9756)) logger.info('WSDL is at: /?wsdl') server.serve_forever() except ImportError: print("Error: example server code requires Python >= 2.5")
except ImportError: print("Error: example server code requires Python >= 2.5") logging.basicConfig(level=logging.DEBUG) logging.getLogger('rpclib.protocol.xml').setLevel(logging.DEBUG) application = Application([HelloWorldService], 'rpclib.examples.events', interface=Wsdl11(), in_protocol=Soap11(), out_protocol=Soap11()) application.event_manager.add_listener('method_call', _on_method_call) application.event_manager.add_listener('method_return_object', _on_method_return_object) application.event_manager.add_listener('method_context_constructed', _on_method_context_constructed) application.event_manager.add_listener('method_context_destroyed', _on_method_context_destroyed) wsgi_wrapper = WsgiApplication(application) wsgi_wrapper.event_manager.add_listener('wsgi_call', _on_wsgi_call) wsgi_wrapper.event_manager.add_listener('wsgi_return', _on_wsgi_return) server = make_server('127.0.0.1', 7789, wsgi_wrapper) print("listening to http://127.0.0.1:7789") print("wsdl is at: http://localhost:7789/?wsdl") server.serve_forever()
def test_complex(self): class CM(ComplexModel): i = Integer s = String class CCM(ComplexModel): c = CM i = Integer s = String class SomeService(ServiceBase): @srpc(CCM, _returns=CCM) def some_call(ccm): return CCM(c=ccm.c,i=ccm.i, s=ccm.s) app = Application([SomeService], 'tns', HttpRpc(), HtmlMicroFormat(), Wsdl11()) server = WsgiApplication(app) initial_ctx = WsgiMethodContext(server, { 'QUERY_STRING': 'ccm_c_s=abc&ccm_c_i=123&ccm_i=456&ccm_s=def', 'PATH_INFO': '/some_call', 'REQUEST_METHOD': 'GET', }, 'some-content-type') ctx, = server.generate_contexts(initial_ctx) server.get_in_object(ctx) server.get_out_object(ctx) server.get_out_string(ctx) # # Here's what this is supposed to return: # # <div class="some_callResponse"> # <div class="some_callResult"> # <div class="i">456</div> # <div class="c"> # <div class="i">123</div> # <div class="s">abc</div> # </div> # <div class="s">def</div> # </div> # </div> # elt = html.fromstring(''.join(ctx.out_string)) resp = elt.find_class('some_callResponse') assert len(resp) == 1 res = resp[0].find_class('some_callResult') assert len(res) == 1 i = res[0].findall('div[@class="i"]') assert len(i) == 1 assert i[0].text == '456' c = res[0].findall('div[@class="c"]') assert len(c) == 1 c_i = c[0].findall('div[@class="i"]') assert len(c_i) == 1 assert c_i[0].text == '123' c_s = c[0].findall('div[@class="s"]') assert len(c_s) == 1 assert c_s[0].text == 'abc' s = res[0].findall('div[@class="s"]') assert len(s) == 1 assert s[0].text == 'def'
raise Fault("Client.FileName", "File '%s' not found" % file_path) document = open(file_path, 'rb').read() # the service automatically loads the data from the file. # alternatively, The data could be manually loaded into memory # and loaded into the Attachment like: # document = Attachment(data=data_from_file) return [document] if __name__ == '__main__': try: from wsgiref.simple_server import make_server except ImportError: print("Error: example server code requires Python >= 2.5") application = Application([DocumentArchiver], 'rpclib.examples.binary', interface=Wsdl11(), in_protocol=HttpRpc(), out_protocol=HttpRpc()) logging.basicConfig(level=logging.DEBUG) server = make_server('127.0.0.1', 7789, WsgiApplication(application)) print("listening to http://127.0.0.1:7789") print("wsdl is at: http://localhost:7789/?wsdl") server.serve_forever()
for tz in tz_matches: time_tz = timezone(tz) print(tz, ': ', str(datetime.now(time_tz))) string = string + tz + str(datetime.now(time_tz)) + '\n' return string if __name__ == '__main__': try: from wsgiref.simple_server import make_server except ImportError: print "Error: server requires Python >= 2.5" logging.basicConfig(level=logging.INFO) logging.getLogger('rpclib.protocol.xml').setLevel(logging.DEBUG) application = Application( [tz], 'org.temporary.soap', # interface=Wsdl11(), in_protocol=Soap11(), out_protocol=Soap11()) # port = int(os.environ.get('PORT', 5000)) port = 8000 server = make_server('127.0.0.1', port, WsgiApplication(application)) print "listening to http://127.0.0.1:%s" % port print "wsdl is at: http://127.0.0.1:%s/?wsdl" % port server.serve_forever()
def send_location(clientid): print "Asking the RMI Server about ", clientid push_property = Pyro4.Proxy("PYRONAME:property.id") a = push_property.scanProplist(clientid) yield str(a) if __name__ == '__main__': try: from wsgiref.simple_server import make_server except ImportError: print "Error: server requires Python >= 2.5" logging.basicConfig(level=logging.INFO) logging.getLogger('rpclib.protocol.xml').setLevel(logging.DEBUG) application = Application([MessageService], 'org.temporary.soap', interface=Wsdl11(), in_protocol=Soap11(), out_protocol=Soap11()) port = int(os.environ.get('PORT', 5007)) server = make_server('0.0.0.0', port, WsgiApplication(application)) print "listening to http://0.0.0.0:%s" % port print "wsdl is at: http://0.0.0.0:%s/?wsdl" % port server.serve_forever()
class HelloWorldService(ServiceBase): @srpc(String, Integer, _returns=Array(String)) def say_hello(name, times): '''Docstrings for service methods appear as documentation in the wsdl. @param name the name to say hello to @param the number of times to say hello @return the completed array ''' results = [] for i in range(0, times): results.append('Hello, %s' % name) return results if __name__ == '__main__': application = Application([HelloWorldService], 'rpclib.examples.hello.twisted', interface=Wsdl11(), in_protocol=Soap11(), out_protocol=Soap11()) wsgi_app = WsgiApplication(application) print('listening on 0.0.0.0:7789') print('wsdl is at: http://0.0.0.0:7789/app/?wsdl') run_twisted(((wsgi_app, "app"), ), 7789)
def test_complex_array(self): class CM(ComplexModel): i = Integer s = String class CCM(ComplexModel): c = CM i = Integer s = String class SomeService(ServiceBase): @srpc(CCM, _returns=Array(CCM)) def some_call(ccm): return [ccm] * 5 app = Application([SomeService], 'tns', HttpRpc(), HtmlTable(field_name_attr='class'), Wsdl11()) server = WsgiApplication(app) initial_ctx = WsgiMethodContext(server, { 'QUERY_STRING': 'ccm_c_s=abc&ccm_c_i=123&ccm_i=456&ccm_s=def', 'PATH_INFO': '/some_call', 'REQUEST_METHOD': 'GET', }, 'some-content-type') ctx, = server.generate_contexts(initial_ctx) server.get_in_object(ctx) server.get_out_object(ctx) server.get_out_string(ctx) out_string = ''.join(ctx.out_string) elt = html.fromstring(out_string) print html.tostring(elt, pretty_print=True) resp = elt.find_class('some_callResponse') assert len(resp) == 1 for i in range(len(elt)): row = elt[i] if i == 0: cell = row.findall('th[@class="i"]') assert len(cell) == 1 assert cell[0].text == 'i' cell = row.findall('th[@class="c_i"]') assert len(cell) == 1 assert cell[0].text == 'c_i' cell = row.findall('th[@class="c_s"]') assert len(cell) == 1 assert cell[0].text == 'c_s' cell = row.findall('th[@class="s"]') assert len(cell) == 1 assert cell[0].text == 's' else: cell = row.findall('td[@class="i"]') assert len(cell) == 1 assert cell[0].text == '456' cell = row.findall('td[@class="c_i"]') assert len(cell) == 1 assert cell[0].text == '123' cell = row.findall('td[@class="c_s"]') assert len(cell) == 1 assert cell[0].text == 'abc' cell = row.findall('td[@class="s"]') assert len(cell) == 1 assert cell[0].text == 'def'
# import logging logging.basicConfig(level=logging.DEBUG) logging.getLogger('rpclib.protocol.xml').setLevel(logging.DEBUG) logger = logging.getLogger('rpclib.test.interop.server.soap_http_basic') from rpclib.server.wsgi import WsgiApplication from rpclib.test.interop.server._service import services from rpclib.application import Application from rpclib.protocol.soap import Soap11 from rpclib.interface.wsdl import Wsdl11 soap_application = Application(services, 'rpclib.test.interop.server', Wsdl11(), Soap11(validator='lxml'), Soap11()) if __name__ == '__main__': try: from wsgiref.simple_server import make_server from wsgiref.validate import validator wsgi_application = WsgiApplication(soap_application) server = make_server('0.0.0.0', 9753, validator(wsgi_application)) logger.info('Starting interop server at %s:%s.' % ('0.0.0.0', 9753)) logger.info('WSDL is at: /?wsdl') server.serve_forever() except ImportError: print("Error: example server code requires Python >= 2.5")