def test_portypes(self): app = Application([TestService], 'tns') _wsdl = app.get_wsdl('') wsdl = etree.fromstring(_wsdl) porttype = wsdl.find('{http://schemas.xmlsoap.org/wsdl/}portType') srv = TestService() self.assertEquals( len(srv.public_methods), len(porttype.getchildren()))
def test_wsdl(self): app = Application([TestService],'tns') wsdl = app.get_wsdl('punk') elt = etree.fromstring(wsdl) simple_type = elt.xpath('//xs:simpleType', namespaces=app.nsmap)[0] # Avoid printing debug output during test runs. #print etree.tostring(elt, pretty_print=True) #print simple_type self.assertEquals(simple_type.attrib['name'], 'DaysOfWeekEnum') self.assertEquals(simple_type[0].tag, "{%s}restriction" % namespaces.ns_xsd) self.assertEquals([e.attrib['value'] for e in simple_type[0]], vals)
def test_wsdl(self): app = Application([TestService], 'tns') wsdl = app.get_wsdl('punk') elt = etree.fromstring(wsdl) simple_type = elt.xpath('//xs:simpleType', namespaces=app.nsmap)[0] # Avoid printing debug output during test runs. #print etree.tostring(elt, pretty_print=True) #print simple_type self.assertEquals(simple_type.attrib['name'], 'DaysOfWeekEnum') self.assertEquals(simple_type[0].tag, "{%s}restriction" % namespaces.ns_xsd) self.assertEquals([e.attrib['value'] for e in simple_type[0]], vals)
def test_multiple_return(self): app = Application([MultipleReturnService], 'tns') app.get_wsdl('') srv = MultipleReturnService() message = srv.public_methods[0].out_message() self.assertEquals(len(message._type_info), 3) sent_xml = etree.Element('test') message.to_parent_element( ('a','b','c'), srv.get_tns(), sent_xml ) sent_xml = sent_xml[0] response_data = message.from_xml(sent_xml) self.assertEquals(len(response_data), 3) self.assertEqual(response_data[0], 'a') self.assertEqual(response_data[1], 'b') self.assertEqual(response_data[2], 'c')
def __get_binding_application(self, binding_service): '''Builds an instance of soaplib.Application The Application built is populated with an instance of a Service Class based on DefinitionBase @param A class based on DefinitionBase ''' binding_application = Application([binding_service], 'binding_application') # The lxml Element nsmap is being overridden to remove the unneeded # namespaces binding_application.nsmap = XSDGenerator.model_schema_nsmap binding_application.prefmap = \ dict([(b,a) for a,b in XSDGenerator.model_schema_nsmap.items()]) binding_application.call_routes = {} return binding_application
def __get_binding_application(self, binding_service, model): """Builds an instance of soaplib.Application The Application built is populated with an instance of a Service Class based on DefinitionBase @param binding_service: class based on DefinitionBase @param model: An ClassModel """ binding_application = Application([binding_service], model.get_namespace()) # The lxml Element nsmap is being overridden to remove the unneeded # namespaces binding_application.nsmap = XSDGenerator.model_schema_nsmap binding_application.prefmap = \ dict([(b,a) for a,b in XSDGenerator.model_schema_nsmap.items()]) binding_application.call_routes = {} if self.custom_map: for prefix, namespace in self.custom_map.items(): binding_application.set_namespace_prefix(namespace, prefix) return binding_application
def build_app(service_list, tns, name): app = Application(service_list, tns, name) app.transport = 'http://schemas.xmlsoap.org/soap/http' return app
def __init__(self, tns, environ=None): super(DefinitionBase, self).__init__(environ) self.soap_app = Application(self, tns, False) self.soap_handler = BaseServer(self.soap_app)
class SoapFolder(DefinitionBase): """Mix-In Class to Make a Folder into a SOAP Service Point Import this class into your Zope2 folder classes to make them SOAP-aware. Any methods in your folder class decorated with @soapmethod() will become callable over SOAP and the signature and docstring of that method will be reported as WSDL by a call to the index_html() method of that folder. Your class should also define a class attribute indicating the 'toplevel namespace' of your SOAP Service Point. This name is arbitrary as far as this code goes, but appears in the SOAP response and the WSDL description generated. This attribute looks like: __tns__ = "PatientServices" """ _v_soap_methods = None _v_cached_wsdl = None __wsdl__ = None def __init__(self, tns, environ=None): super(DefinitionBase, self).__init__(environ) self.soap_app = Application(self, tns, False) self.soap_handler = BaseServer(self.soap_app) def methods(self): """Returns a list of method descriptors for this object""" if self._v_soap_methods is None: self._v_soap_methods = self.build_public_methods() return self._v_soap_methods def service_description(self, REQUEST, RESPONSE): """ """ if getattr(self, '__tns__', None) is None: self.__tns__ = self.get_tns(self.__class__) if self._v_soap_methods is None: self._v_soap_methods = self.build_public_methods() if self._v_cached_wsdl is None: self._v_cached_wsdl = self.soap_app.get_wsdl(self.absolute_url()) self.__wsdl__ = None RESPONSE.setHeader('Content-Type', 'text/xml') return self._v_cached_wsdl def index_html(self, REQUEST, RESPONSE): """Handle an incoming SOAP request or a non-SOAP WSDL query.""" if REQUEST.get('SOAPXML', None) == None: # Not a SOAP Request, return WSDL return self.service_description(REQUEST, RESPONSE) try: # Deserialize the Body of the SOAP Request from soaplib.core._base import _from_soap header, payload = _from_soap(REQUEST.SOAPXML) # TODO: At this point I need dispatch method calls to the soaplib.Application # somehow....... :) ctx = MethodContext() content_type = cgi.parse_header(REQUEST.get("Content-Type")) charset = content_type[1].get('charset',None) length = REQUEST.get("Content-Length") http_payload = REQUEST.read(int(length)) if not charset: charset = "ascii" in_string = collapse_swa(content_type, http_payload) in_obj = self.soap_handler.get_in_object(ctx, in_string, charset) out_obj = self.soap_handler.get_out_object(ctx, in_obj) out_string = self.soap_handler.get_out_string(ctx, out_obj) return out_string except Exception, e: fault = Fault(faultstring=str(e)) resp = etree.tostring(fault, encoding=string_encoding) RESPONSE.setStatus('InternalServerError', reason=faultstring) RESPONSE.setHeader('Content-Type', 'text/xml') return resp
#return the order unique id logger.info("Backoffice: Returning async request for submit order") return new_order.id @soap(Integer, Integer, Auth, _returns=String) def getBudgetResponse(self, order, price, auth): if is_valid_request(auth): create_budget(auth.user_id, order, price) verify_and_finalize_order(order) @soap(Integer, String, Auth, _returns=String) def setStatusOrder(self, order, status, auth): if is_valid_request(auth): Notificator(order).notificate_frontend(status) return "OK" if __name__ == "__main__": host = sys.argv[1] port = int(sys.argv[2]) soap_application = Application([MusicService, OrderService], 'tns') wsgi_application = wsgi.Application(soap_application) server = make_server(host, port, wsgi_application) logger.info("Backoffice serving on %s:%s" % ( host, port, )) server.serve_forever()
def test_multiple_ns(self): svc = Application([MultipleNamespaceService], 'tns') wsdl = svc.get_wsdl("URL")
''' class SleepingService(DefinitionBase): @soap(Integer, _is_async=True) def sleep(self, seconds): msgid, replyto = get_callback_info() def run(): time.sleep(seconds) client = make_service_client(replyto, self) client.woke_up('good morning', msgid=msgid) Thread(target=run).start() @soap(String, _is_callback=True) def woke_up(self, message): pass if __name__ == '__main__': try: from wsgiref.simple_server import make_server soap_app = Application([SleepingService], 'tns') wsgi_app = wsgi.Application(soap_app) server = make_server('localhost', 7789, wsgi_app) server.serve_forever() except ImportError: print "Error: example server code requires Python >= 2.5"
return user_database[userid] @soap(User) def modify_user(self, user): global user_database user_database[user.userid] = user @soap(Integer) def delete_user(self, userid): global user_database del user_database[userid] @soap(_returns=Array(User)) def list_users(self): global user_database return [v for k, v in user_database.items()] if __name__ == '__main__': try: from wsgiref.simple_server import make_server soap_app = Application([UserManager], 'tns') wsgi_app = wsgi.Application(soap_app) server = make_server('localhost', 7789, wsgi_app) server.serve_forever() except ImportError: print "Error: example server code requires Python >= 2.5"
computerid_seq = 1 class Computer(ClassModel): __namespace__ = "assets" assetid = Integer description = String class ComputerManager(DefinitionBase): @soap(Computer, _returns=Computer) def add_computer(self, computer): global computer_database global computerid_seq computer.assetid = computerid_seq computerid_seq += 1 computer_database[computer.assetid] = computer return computer.assetid if __name__ == "__main__": from wsgiref.simple_server import make_server soap_app = Application([ComputerManager, UserManager],tns="itServices") wsgi_app = wsgi.Application(soap_app) server = make_server("localhost", 7789, wsgi_app) server.serve_forever()
def __init__(self, services, tns): """Create Django view for given SOAP soaplib services and tns""" return super(DjangoSoapApp, self).__init__(Application(services, tns))
def as_view(cls): soap_application = Application([cls], __name__) return DjangoSoapApp(soap_application)
def form_valid(self, form): slug = form.cleaned_data['slug'] return HttpResponseRedirect( reverse('list_order', args=[slug]) ) class ListOrderView(DetailView): context_object_name = 'order' model = Order template_name = 'list_order.html' @method_decorator(login_required) def dispatch(self, *args, **kwargs): return super(ListOrderView, self).dispatch(*args, **kwargs) class OrderStatusService(DefinitionBase): @soap(Integer, String, _returns=String) def changeStatusOrder(self, order, status): Order.objects.filter(slug=int(order)).update(status=status) return "OK" orderstatus_service = DjangoSOAPAdaptor( Application( [OrderStatusService], 'tns' ) )
def build_app(service_list, tns, name): app = Application(service_list, tns, name) app.transport = 'http://schemas.xmlsoap.org/soap/http' app.update_pref_map("Hippity", "Hippity") app.update_pref_map("Hoppity","Hoppity") app.update_pref_map("MissingRPCPortService","MissingRPCPortService") app.update_pref_map("SinglePortNS","SinglePortNS") app.update_pref_map("DoublePort","DoublePort") return app
def consturct_soaplib_application(service_list, tns): soap_app = Application(service_list, tns) soap_app.transport = "http://schemas.xmlsoap.org/soap/http" return soap_app
def test_override_param_names(self): app = Application([TestService], 'tns') _wsdl = app.get_wsdl('') for n in ['self', 'import', 'return', 'from']: self.assertTrue(n in _wsdl, '"%s" not in _wsdl' % n)
class SoapFolder(DefinitionBase): """Mix-In Class to Make a Folder into a SOAP Service Point Import this class into your Zope2 folder classes to make them SOAP-aware. Any methods in your folder class decorated with @soapmethod() will become callable over SOAP and the signature and docstring of that method will be reported as WSDL by a call to the index_html() method of that folder. Your class should also define a class attribute indicating the 'toplevel namespace' of your SOAP Service Point. This name is arbitrary as far as this code goes, but appears in the SOAP response and the WSDL description generated. This attribute looks like: __tns__ = "PatientServices" """ _v_soap_methods = None _v_cached_wsdl = None __wsdl__ = None def __init__(self, tns, environ=None): super(DefinitionBase, self).__init__(environ) self.soap_app = Application(self, tns, False) self.soap_handler = BaseServer(self.soap_app) def methods(self): """Returns a list of method descriptors for this object""" if self._v_soap_methods is None: self._v_soap_methods = self.build_public_methods() return self._v_soap_methods def service_description(self, REQUEST, RESPONSE): """ """ if getattr(self, '__tns__', None) is None: self.__tns__ = self.get_tns(self.__class__) if self._v_soap_methods is None: self._v_soap_methods = self.build_public_methods() if self._v_cached_wsdl is None: self._v_cached_wsdl = self.soap_app.get_wsdl(self.absolute_url()) self.__wsdl__ = None RESPONSE.setHeader('Content-Type', 'text/xml') return self._v_cached_wsdl def index_html(self, REQUEST, RESPONSE): """Handle an incoming SOAP request or a non-SOAP WSDL query.""" if REQUEST.get('SOAPXML', None) == None: # Not a SOAP Request, return WSDL return self.service_description(REQUEST, RESPONSE) try: # Deserialize the Body of the SOAP Request from soaplib.core._base import _from_soap header, payload = _from_soap(REQUEST.SOAPXML) # TODO: At this point I need dispatch method calls to the soaplib.Application # somehow....... :) ctx = MethodContext() content_type = cgi.parse_header(REQUEST.get("Content-Type")) charset = content_type[1].get('charset', None) length = REQUEST.get("Content-Length") http_payload = REQUEST.read(int(length)) if not charset: charset = "ascii" in_string = collapse_swa(content_type, http_payload) in_obj = self.soap_handler.get_in_object(ctx, in_string, charset) out_obj = self.soap_handler.get_out_object(ctx, in_obj) out_string = self.soap_handler.get_out_string(ctx, out_obj) return out_string except Exception, e: fault = Fault(faultstring=str(e)) resp = etree.tostring(fault, encoding=string_encoding) RESPONSE.setStatus('InternalServerError', reason=faultstring) RESPONSE.setHeader('Content-Type', 'text/xml') return resp
print 'dm invoke ok!' resInfo = ResultInfo() resInfo.reqNo = reqNo resInfo.resMsg = rs[0] #print resInfo return resInfo class TestService(DefinitionBase): #WebService Method @soap(TestRequestInfo, _returns=ResultInfo) def getResultInfo(self, reqInfo): resInfo = ResultInfo() resInfo = exeRules(reqInfo) #print resInfo return resInfo if __name__ == '__main__': try: print '服务已启动' from wsgiref.simple_server import make_server soap_application = Application([TestService], 'tns') wsgi_application = wsgi.Application(soap_application) server = make_server('localhost', 8899, wsgi_application) server.serve_forever() except ImportError: print 'error'