def __call__(self, *args, **kwargs):
'''
This method executes the http request to the remote web service. With
the exception of 'headers', 'msgid', and 'mtom'; all keyword arguments
to this method are put in the http header. The 'headers' keyword is to
denote a list of elements to be included in the soap header, 'msgid'
is a convenience keyword used in async web services which creates a
WS-Addressing messageid header to be included in the soap headers, and
'mtom' enables the Message Transmission Optimization Mechanism.
@param the arguments to the remote method
@param the keyword arguments
'''
if len(args) != len(self.descriptor.inMessage.params):
argstring = '\r\n'.join([' ' + str(arg) for arg in args])
paramstring = '\r\n'.join([' ' + str(p[0])
for p in self.descriptor.inMessage.params])
err_msg = _err_format % (argstring, paramstring)
raise Exception(err_msg)
msg = self.descriptor.inMessage.to_xml(*args)
# grab the soap headers passed into this call
headers = kwargs.get('headers', [])
mtom = kwargs.get('mtom', False)
msgid = kwargs.get('msgid')
if msgid:
# special case for the msgid field as a convenience
# when dealing with async callback methods
headers.append(create_relates_to_header(msgid))
tns = self.descriptor.inMessage.ns
envelope = make_soap_envelope(msg, tns, header_elements=headers)
body = ElementTree.tostring(envelope)
methodName = '\"%s\"' % self.descriptor.soapAction
httpHeaders = {'Content-Length': len(body),
'Content-type': 'text/xml; charset="UTF-8"',
'Accept': ('application/soap+xml, application/dime, '
'multipart/related, text/*'),
'User-Agent': 'Soaplib/1.0',
'SOAPAction': methodName,
}
for k, v in kwargs.items():
# add all the other keywords to the http headers
if k not in ('headers', 'msgid', 'mtom'):
httpHeaders[k] = v
if mtom:
httpHeaders, body = apply_mtom(httpHeaders, body,
self.descriptor.inMessage.params, args)
dump(self.host, self.path, httpHeaders, body)
if self.scheme == "http":
conn = httplib.HTTPConnection(self.host)
elif self.scheme == "https":
conn = httplib.HTTPSConnection(self.host)
else:
raise RuntimeError("Unsupported URI connection scheme: %s" %
self.scheme)
conn.request("POST", self.path, body=body, headers=httpHeaders)
response = conn.getresponse()
data = response.read()
dump(self.host, self.path, dict(response.getheaders()), data)
contenttype = response.getheader('Content-Type')
data = collapse_swa(contenttype, data)
conn.close()
if str(response.status) not in['200', '202']:
# consider everything NOT 200 or 202 as an error response
if str(response.status) == '500':
fault = None
try:
payload, headers = from_soap(data)
fault = Fault.from_xml(payload)
except:
trace = StringIO()
import traceback
traceback.print_exc(file=trace)
fault = Exception("Unable to read response \n"
"%s %s \n %s \n %s" %
(response.status, response.reason, trace.getvalue(),
data))
raise fault
else:
raise Exception("%s %s" % (response.status, response.reason))
if not self.descriptor.outMessage.params:
return
payload, headers = from_soap(data)
results = self.descriptor.outMessage.from_xml(payload)
return results[0]
def __call__(self, *args, **kwargs):
'''
This method executes the http request to the remote web service. With
the exception of 'headers', 'msgid', and 'mtom'; all keyword arguments
to this method are put in the http header. The 'headers' keyword is to
denote a list of elements to be included in the soap header, 'msgid'
is a convenience keyword used in async web services which creates a
WS-Addressing messageid header to be included in the soap headers, and
'mtom' enables the Message Transmission Optimization Mechanism.
@param the arguments to the remote method
@param the keyword arguments
'''
if len(args) != len(self.descriptor.inMessage.params):
argstring = '\r\n'.join([' ' + str(arg) for arg in args])
paramstring = '\r\n'.join(
[' ' + str(p[0]) for p in self.descriptor.inMessage.params])
err_msg = _err_format % (argstring, paramstring)
raise Exception(err_msg)
msg = self.descriptor.inMessage.to_xml(*args)
# grab the soap headers passed into this call
headers = kwargs.get('headers', [])
mtom = kwargs.get('mtom', False)
msgid = kwargs.get('msgid')
if msgid:
# special case for the msgid field as a convenience
# when dealing with async callback methods
headers.append(create_relates_to_header(msgid))
tns = self.descriptor.inMessage.ns
envelope = make_soap_envelope(msg, tns, header_elements=headers)
body = ElementTree.tostring(envelope)
methodName = '\"%s\"' % self.descriptor.soapAction
httpHeaders = {
'Content-Length':
len(body),
'Content-type':
'text/xml; charset="UTF-8"',
'Accept': ('application/soap+xml, application/dime, '
'multipart/related, text/*'),
'User-Agent':
'Soaplib/1.0',
'SOAPAction':
methodName,
}
for k, v in kwargs.items():
# add all the other keywords to the http headers
if k not in ('headers', 'msgid', 'mtom'):
httpHeaders[k] = v
if mtom:
httpHeaders, body = apply_mtom(httpHeaders, body,
self.descriptor.inMessage.params,
args)
dump(self.host, self.path, httpHeaders, body)
if self.scheme == "http":
conn = httplib.HTTPConnection(self.host)
elif self.scheme == "https":
conn = httplib.HTTPSConnection(self.host)
else:
raise RuntimeError("Unsupported URI connection scheme: %s" %
self.scheme)
conn.request("POST", self.path, body=body, headers=httpHeaders)
response = conn.getresponse()
data = response.read()
dump(self.host, self.path, dict(response.getheaders()), data)
contenttype = response.getheader('Content-Type')
data = collapse_swa(contenttype, data)
conn.close()
if str(response.status) not in ['200', '202']:
# consider everything NOT 200 or 202 as an error response
if str(response.status) == '500':
fault = None
try:
payload, headers = from_soap(data)
fault = Fault.from_xml(payload)
except:
trace = StringIO()
import traceback
traceback.print_exc(file=trace)
fault = Exception("Unable to read response \n"
"%s %s \n %s \n %s" %
(response.status, response.reason,
trace.getvalue(), data))
raise fault
else:
raise Exception("%s %s" % (response.status, response.reason))
if not self.descriptor.outMessage.params:
return
payload, headers = from_soap(data)
results = self.descriptor.outMessage.from_xml(payload)
#TODO: consider supporting multiple return types in a better manner
if len(results) > 1:
return results
return results[0]
class WSGISoapApp(object):
'''
This is the base object representing a soap web application, and conforms
to the WSGI specification (PEP 333). This object should be overridden
and getHandler(environ) overridden to provide the object implementing
the specified functionality. Hooks have been added so that the subclass
can react to various events that happen durring the execution of the
request.
'''
def onCall(self, environ):
'''
This is the first method called when this WSGI app is invoked
@param the wsgi environment
'''
pass
def onWsdl(self, environ, wsdl):
'''
This is called when a wsdl is requested
@param the wsgi environment
@param the wsdl string
'''
pass
def onWsdlException(self, environ, exc, resp):
'''
Called when an exception occurs durring wsdl generation
@param the wsgi environment
@param exc the exception
@param the fault response string
'''
pass
def onMethodExec(self, environ, body, py_params, soap_params):
'''
Called BEFORE the service implementing the functionality is called
@param the wsgi environment
@param the body element of the soap request
@param the tuple of python params being passed to the method
@param the soap elements for each params
'''
pass
def onResults(self, environ, py_results, soap_results):
'''
Called AFTER the service implementing the functionality is called
@param the wsgi environment
@param the python results from the method
@param the xml serialized results of the method
'''
pass
def onException(self, environ, exc, resp):
'''
Called when an error occurs durring execution
@param the wsgi environment
@param the exception
@param the response string
'''
pass
def onReturn(self, environ, returnString):
'''
Called before the application returns
@param the wsgi environment
@param return string of the soap request
'''
pass
def getHandler(self, environ):
'''
This method returns the object responsible for processing a given
request, and needs to be overridden by a subclass to handle
the application specific mapping of the request to the appropriate
handler.
@param the wsgi environment
@returns the object to be called for the soap operation
'''
raise Exception("Not implemented")
def __call__(self, environ, start_response, address_url=None):
'''
This method conforms to the WSGI spec for callable wsgi applications
(PEP 333). It looks in environ['wsgi.input'] for a fully formed soap
request envelope, will deserialize the request parameters and call the
method on the object returned by the getHandler() method.
@param the http environment
@param a callable that begins the response message
@returns the string representation of the soap call
'''
methodname = ''
try:
reset_request()
request.environ = environ
# implementation hook
self.onCall(environ)
serviceName = environ['PATH_INFO'].split('/')[-1]
service = self.getHandler(environ)
if ((environ['QUERY_STRING'].endswith('wsdl')
or environ['PATH_INFO'].endswith('wsdl'))
and environ['REQUEST_METHOD'].lower() == 'get'):
# get the wsdl for the service
#
# Assume path_info matches pattern
# /stuff/stuff/stuff/serviceName.wsdl or ?WSDL
#
serviceName = serviceName.split('.')[0]
if address_url:
url = address_url
else:
url = reconstruct_url(environ).split('.wsdl')[0]
start_response('200 OK', [('Content-type', 'text/xml')])
try:
wsdl_content = service.wsdl(url)
# implementation hook
self.onWsdl(environ, wsdl_content)
except Exception, e:
# implementation hook
buffer = cStringIO.StringIO()
traceback.print_exc(file=buffer)
buffer.seek(0)
stacktrace = str(buffer.read())
faultStr = ElementTree.tostring(make_soap_fault(
str(e), detail=stacktrace),
encoding=string_encoding)
exceptions(faultStr)
self.onWsdlException(environ, e, faultStr)
# initiate the response
start_response('500',
[('Content-type', 'text/xml'),
('Content-length', str(len(faultStr)))])
return [faultStr]
reset_request()
return [wsdl_content]
if environ['REQUEST_METHOD'].lower() != 'post':
start_response('405 Method Not Allowed', [('Allow', 'POST')])
return ''
input = environ.get('wsgi.input')
length = environ.get("CONTENT_LENGTH")
body = input.read(int(length))
debug(body)
body = collapse_swa(environ.get("CONTENT_TYPE"), body)
# deserialize the body of the message
try:
payload, header = from_soap(body)
except SyntaxError, e:
payload = None
header = None
if payload:
methodname = payload.tag.split('}')[-1]
else:
# check HTTP_SOAPACTION
methodname = environ.get("HTTP_SOAPACTION")
if methodname.startswith('"') and methodname.endswith('"'):
methodname = methodname[1:-1]
if methodname.find('/') > 0:
methodname = methodname.split('/')[1]
request.header = header
# call the method
func = getattr(service, methodname)
# retrieve the method descriptor
descriptor = func(_soap_descriptor=True, klazz=service.__class__)
if payload:
params = descriptor.inMessage.from_xml(*[payload])
else:
params = ()
# implementation hook
self.onMethodExec(environ, body, params,
descriptor.inMessage.params)
# call the method
retval = func(*params)
# transform the results into an element
# only expect a single element
results = None
if not (descriptor.isAsync or descriptor.isCallback):
results = descriptor.outMessage.to_xml(*[retval])
# implementation hook
self.onResults(environ, results, retval)
# grab any headers that were included in the request
response_headers = None
if hasattr(request, 'response_headers'):
response_headers = request.response_headers
# construct the soap response, and serialize it
envelope = make_soap_envelope(results,
tns=service.__tns__,
header_elements=response_headers)
ElementTree.cleanup_namespaces(envelope)
resp = ElementTree.tostring(envelope, encoding=string_encoding)
headers = {'Content-Type': 'text/xml'}
if descriptor.mtom:
headers, resp = apply_mtom(headers, resp,
descriptor.outMessage.params,
(retval, ))
if 'CONTENT_LENGTH' in environ:
del environ['CONTENT_LENGTH']
# initiate the response
start_response('200 OK', headers.items())
self.onReturn(environ, resp)
debug(resp)
# return the serialized results
reset_request()
return [resp]
def __call__(self, environ, start_response):
'''
This method conforms to the WSGI spec for callable wsgi applications (PEP 333).
This method looks in environ['wsgi.input'] for a fully formed soap request envelope,
will deserialize the request parameters and call the method on the object returned
by the getHandler() method.
@param the http environment
@param a callable that begins the response message
@returns the string representation of the soap call
'''
methodname = ''
try:
reset_request()
request.environ = environ
# implementation hook
self.onCall(environ)
serviceName = environ['PATH_INFO'].split('/')[-1]
service = self.getHandler(environ)
if serviceName.lower().endswith('wsdl'):
# get the wsdl for the service
#
# Assume path_info matches pattern
# /stuff/stuff/stuff/serviceName.wsdl or ?WSDL
#
serviceName = serviceName.split('.')[0]
url = reconstruct_url(environ).split('.wsdl')[0]
start_response('200 OK',[('Content-type','text/xml')])
try:
wsdl_content = service.wsdl(url)
# implementation hook
self.onWsdl(environ,wsdl_content)
except Exception, e:
# implementation hook
buffer = cStringIO.StringIO()
traceback.print_exc(file=buffer)
buffer.seek(0)
stacktrace = str(buffer.read())
faultStr = ElementTree.tostring(make_soap_fault( str(e), detail=stacktrace), encoding=string_encoding)
exceptions(faultStr)
self.onWsdlException(environ,e,faultStr)
# initiate the response
start_response('500',[('Content-type','text/xml'),('Content-length',str(len(faultStr)))])
return [faultStr]
reset_request()
return [wsdl_content]
if environ['REQUEST_METHOD'].lower() != 'post':
start_response('405 Method Not Allowed',[('Allow','POST')])
return ''
input = environ.get('wsgi.input')
length = environ.get("CONTENT_LENGTH")
body = input.read(int(length))
debug(body)
body = collapse_swa( environ.get("CONTENT_TYPE"), body)
# deserialize the body of the message
payload, header = from_soap(body)
if payload:
methodname = payload.tag.split('}')[-1]
else:
# check HTTP_SOAPACTION
methodname = environ.get("HTTP_SOAPACTION")
if methodname.startswith('"') and methodname.endswith('"'):
methodname = methodname[1:-1]
request.header = header
# call the method
func = getattr(service, methodname)
# retrieve the method descriptor
descriptor = func(_soap_descriptor=True)
if payload:
params = descriptor.inMessage.from_xml(*[payload])
else:
params = ()
# implementation hook
self.onMethodExec(environ,body,params,descriptor.inMessage.params)
# call the method
retval = func(*params)
# transform the results into an element
# only expect a single element
results = None
if not (descriptor.isAsync or descriptor.isCallback):
results = descriptor.outMessage.to_xml(*[retval])
# implementation hook
self.onResults(environ,results,retval)
# grab any headers that were included in the request
response_headers = None
if hasattr(request,'response_headers'):
response_headers = request.response_headers
# construct the soap response, and serialize it
envelope = make_soap_envelope(results,tns=service.__tns__,header_elements=response_headers)
resp = ElementTree.tostring(envelope, encoding=string_encoding)
headers = {'Content-Type': 'text/xml'}
if descriptor.mtom:
headers, resp = apply_mtom( headers, resp,
descriptor.outMessage.params,
(retval,) )
if environ.has_key('CONTENT_LENGTH'):
del(environ['CONTENT_LENGTH'])
# initiate the response
start_response('200 OK',headers.items())
self.onReturn(environ,resp)
debug(resp)
# return the serialized results
reset_request()
return [resp]
def __handle_soap_request(self, req_env, start_response, url):
http_resp_headers = {
'Content-Type': 'text/xml',
'Content-Length': '0',
}
method_name = None
try:
# implementation hook
self.on_call(req_env)
if req_env['REQUEST_METHOD'].lower() != 'post':
http_resp_headers['Allow'] = 'POST'
start_response(HTTP_405, http_resp_headers.items())
return ['']
input = req_env.get('wsgi.input')
length = req_env.get("CONTENT_LENGTH")
body = input.read(int(length))
try:
service = None
soap_req_header, soap_req_payload = self.__decode_soap_request(
req_env, body)
self.validate_request(soap_req_payload)
method_name = self.__get_method_name(req_env, soap_req_payload)
if method_name is None:
resp = "Could not get method name!"
http_resp_headers['Content-Length'] = str(len(resp))
start_response(HTTP_500, http_resp_headers.items())
return [resp]
service_class = self.get_service_class(method_name)
service = self.get_service(service_class, req_env)
finally:
# for performance reasons, we don't want the following to run
# in production even though we won't see the results.
if logger.level == logging.DEBUG:
try:
logger.debug(etree.tostring(etree.fromstring(body),
pretty_print=True))
except:
logger.debug(body)
raise
# retrieve the method descriptor
descriptor = service.get_method(method_name)
func = getattr(service, descriptor.name)
serializers = service.get_serializers()
# decode header object
if soap_req_header is not None and len(soap_req_header) > 0:
in_header = descriptor.in_header
service.soap_in_header = in_header.from_xml(soap_req_header, serializers)
# decode method arguments
if soap_req_payload is not None and len(soap_req_payload) > 0:
params = descriptor.in_message.from_xml(soap_req_payload, serializers)
else:
params = [None] * len(descriptor.in_message._type_info)
# implementation hook
service.on_method_call(req_env, method_name, params,
soap_req_payload)
# call the method
result_raw = service.call_wrapper(func, params)
# construct the soap response, and serialize it
envelope = etree.Element('{%s}Envelope' % soaplib.ns_soap_env,
nsmap=soaplib.nsmap)
#
# header
#
soap_header_elt = etree.SubElement(envelope,
'{%s}Header' % soaplib.ns_soap_env)
if service.soap_out_header != None:
if descriptor.out_header is None:
logger.warning("Skipping soap response header as %r method "
"is not published to have a soap response "
"header" % method_name)
else:
descriptor.out_header.to_xml(
service.soap_out_header,
self.get_tns(),
soap_header_elt,
descriptor.out_header.get_type_name()
)
if len(soap_header_elt) > 0:
envelope.append(soap_header_elt)
#
# body
#
soap_body = etree.SubElement(envelope,
'{%s}Body' % soaplib.ns_soap_env)
# instantiate the result message
result_message = descriptor.out_message()
# assign raw result to its wrapper, result_message
out_type = descriptor.out_message._type_info
if len(out_type) > 0:
assert len(out_type) == 1
attr_name = descriptor.out_message._type_info.keys()[0]
setattr(result_message, attr_name, result_raw)
# transform the results into an element
if not (descriptor.is_async or descriptor.is_callback):
descriptor.out_message.to_xml(result_message, self.get_tns(),
soap_body)
# implementation hook
service.on_method_return(req_env, result_raw, soap_body,
http_resp_headers)
#
# misc
#
results_str = etree.tostring(envelope, xml_declaration=True,
encoding=string_encoding)
if descriptor.mtom:
http_resp_headers, results_str = apply_mtom(http_resp_headers,
results_str, descriptor.out_message._type_info,[result_raw])
# implementation hook
self.on_return(req_env, http_resp_headers, results_str)
# initiate the response
http_resp_headers['Content-Length'] = str(len(results_str))
start_response(HTTP_200, http_resp_headers.items())
if logger.level == logging.DEBUG:
logger.debug('\033[91m'+ "Response" + '\033[0m')
logger.debug(etree.tostring(envelope, xml_declaration=True,
pretty_print=True))
# return the serialized results
return [results_str]
# The user issued a Fault, so handle it just like an exception!
except Fault, e:
return self.__handle_fault(req_env, start_response,
http_resp_headers, service, e)
def _Application__handle_soap_request(self, req_env, start_response, url):
"""
This function is too big.
"""
import threading
curThread = threading.currentThread()
curThread.REMOTE_ADDR = req_env.get('REMOTE_ADDR')
curThread.REMOTE_PORT = req_env.get('REMOTE_PORT')
ip = req_env.get('REMOTE_ADDR')
http_resp_headers = {
'Content-Type': 'text/xml',
'Content-Length': '0',
}
method_name = None
self.create_path()
try:
# implementation hook
self.on_call(req_env)
if req_env['REQUEST_METHOD'].lower() != 'post':
http_resp_headers['Allow'] = 'POST'
start_response(HTTP_405, http_resp_headers.items())
return ['']
input = req_env.get('wsgi.input')
length = req_env.get("CONTENT_LENGTH")
body = input.read(int(length))
try:
service = None
soap_req_header, soap_req_payload = \
self._Application__decode_soap_request(req_env, body)
if not (soap_req_payload is None):
self.validate_request(soap_req_payload)
method_name = \
self._Application__get_method_name \
(req_env, soap_req_payload)
if method_name is None:
resp = "Could not extract method name from the request!"
http_resp_headers['Content-Length'] = str(len(resp))
start_response(HTTP_500, http_resp_headers.items())
return [resp]
service_class = self.get_service_class(method_name)
service = self.get_service(service_class, req_env)
finally:
# for performance reasons, we don't want the following to run
# in production even though we won't see the results.
if logger.level == logging.DEBUG:
try:
logger.debug(etree.tostring(etree.fromstring(body),
pretty_print=True))
except etree.XMLSyntaxError,e:
logger.debug(body)
raise Fault('Client.XMLSyntax',\
'Error at line: %d, col: %d' % e.position)
# retrieve the method descriptor
descriptor = service.get_method(method_name)
func = getattr(service, descriptor.name)
# decode header object
if soap_req_header is not None and len(soap_req_header) > 0:
in_header = descriptor.in_header
service.soap_in_header = in_header.from_xml(soap_req_header)
# decode method arguments
if soap_req_payload is not None and len(soap_req_payload) > 0:
params = descriptor.in_message.from_xml(soap_req_payload)
else:
params = [None] * len(descriptor.in_message._type_info)
#### check_rights
import threading
curThread = threading.currentThread()
if hasattr (params, 'sid'):
curThread.lang = service.get_lang(params.sid)
# check exists client certificate
if not hasattr (curThread, 'client_cert'):
curThread.client_cert = None
# check rights client certificate for the method
check = self.check_rights(method_name, req_env, params)
if not check:
if curThread.client_cert:
certobj = OpenSSL.crypto.load_certificate \
(OpenSSL.SSL.FILETYPE_PEM, curThread.client_cert)
finger = certobj.digest('SHA1')
self.log.debug('%s %s %s forbidden %s' \
%(datetime.datetime.now().__str__(), finger, ip, \
method_name[5:]))
resp = "Permission denied: " + method_name
http_resp_headers['Content-Length'] = str(len(resp))
start_response(HTTP_403, http_resp_headers.items())
return [resp]
#### logging
if curThread.client_cert:
certobj = OpenSSL.crypto.load_certificate \
(OpenSSL.SSL.FILETYPE_PEM, curThread.client_cert)
finger = certobj.digest('SHA1')
if not method_name[5:] in not_log_list and \
not method_name[5:].endswith('_view'):
self.log.debug('%s %s %s allowed %s' \
%(datetime.datetime.now().__str__(), finger, ip, \
method_name[5:]))
# implementation hook
service.on_method_call(req_env, method_name, params,
soap_req_payload)
# call the method
result_raw = service.call_wrapper(func, params)
# construct the soap response, and serialize it
envelope = etree.Element('{%s}Envelope' % soaplib.ns_soap_env,
nsmap=soaplib.nsmap)
#
# header
#
soap_header_elt = etree.SubElement(envelope,
'{%s}Header' % soaplib.ns_soap_env)
if service.soap_out_header != None:
if descriptor.out_header is None:
logger.warning("Skipping soap response header as %r "
"method is not published to have a soap "
"response header" % method_name)
else:
descriptor.out_header.to_xml(
service.soap_out_header,
self.get_tns(),
soap_header_elt,
descriptor.out_header.get_type_name()
)
if len(soap_header_elt) > 0:
envelope.append(soap_header_elt)
#
# body
#
soap_body = etree.SubElement(envelope,
'{%s}Body' % soaplib.ns_soap_env)
# instantiate the result message
result_message = descriptor.out_message()
# assign raw result to its wrapper, result_message
out_type = descriptor.out_message._type_info
if len(out_type) > 0:
if len(out_type) == 1:
attr_name = descriptor.out_message._type_info.keys()[0]
setattr(result_message, attr_name, result_raw)
else:
for i in range(len(out_type)):
attr_name = descriptor.out_message._type_info.keys()[i]
setattr(result_message, attr_name, result_raw[i])
# transform the results into an element
descriptor.out_message.to_xml(result_message, self.get_tns(),
soap_body)
# implementation hook
service.on_method_return(req_env, result_raw, soap_body,
http_resp_headers)
#
# misc
#
results_str = etree.tostring(envelope, xml_declaration=True,
encoding=string_encoding)
if descriptor.mtom:
http_resp_headers, results_str = apply_mtom(http_resp_headers,
results_str, descriptor.out_message._type_info,
[result_raw])
# implementation hook
self.on_return(req_env, http_resp_headers, results_str)
# initiate the response
http_resp_headers['Content-Length'] = str(len(results_str))
start_response(HTTP_200, http_resp_headers.items())
if logger.level == logging.DEBUG:
logger.debug('\033[31m'+ "Response" + '\033[0m')
logger.debug(etree.tostring(envelope, xml_declaration=True,
pretty_print=True))
# return the serialized results
return [results_str]
def __handle_soap_request(self, req_env, start_response, url):
"""
This function is too big.
"""
http_resp_headers = {
'Content-Type': 'text/xml',
'Content-Length': '0',
}
method_name = None
try:
# implementation hook
self.on_call(req_env)
if req_env['REQUEST_METHOD'].lower() != 'post':
http_resp_headers['Allow'] = 'POST'
start_response(HTTP_405, http_resp_headers.items())
return ['']
input = req_env.get('wsgi.input')
length = req_env.get("CONTENT_LENGTH")
body = input.read(int(length))
try:
service = None
soap_req_header, soap_req_payload = self.__decode_soap_request(
req_env, body)
if not (soap_req_payload is None):
self.validate_request(soap_req_payload)
method_name = self.__get_method_name(req_env, soap_req_payload)
if method_name is None:
resp = "Could not extract method name from the request!"
http_resp_headers['Content-Length'] = str(len(resp))
start_response(HTTP_500, http_resp_headers.items())
return [resp]
service_class = self.get_service_class(method_name)
service = self.get_service(service_class, req_env)
finally:
# for performance reasons, we don't want the following to run
# in production even though we won't see the results.
if logger.level == logging.DEBUG:
try:
logger.debug(etree.tostring(etree.fromstring(body),
pretty_print=True))
except etree.XMLSyntaxError,e:
logger.debug(body)
raise Fault('Client.XMLSyntax', 'Error at line: %d, col: %d'
% e.position)
# retrieve the method descriptor
descriptor = service.get_method(method_name)
func = getattr(service, descriptor.name)
# decode header object
if soap_req_header is not None and len(soap_req_header) > 0:
in_header = descriptor.in_header
service.soap_in_header = in_header.from_xml(soap_req_header)
# decode method arguments
if soap_req_payload is not None and len(soap_req_payload) > 0:
params = descriptor.in_message.from_xml(soap_req_payload)
else:
params = [None] * len(descriptor.in_message._type_info)
# implementation hook
service.on_method_call(req_env, method_name, params,
soap_req_payload)
# call the method
result_raw = service.call_wrapper(func, params)
# construct the soap response, and serialize it
envelope = etree.Element('{%s}Envelope' % soaplib.ns_soap_env,
nsmap=soaplib.nsmap)
#
# header
#
soap_header_elt = etree.SubElement(envelope,
'{%s}Header' % soaplib.ns_soap_env)
if service.soap_out_header != None:
if descriptor.out_header is None:
logger.warning("Skipping soap response header as %r method "
"is not published to have a soap response "
"header" % method_name)
else:
descriptor.out_header.to_xml(
service.soap_out_header,
self.get_tns(),
soap_header_elt,
descriptor.out_header.get_type_name()
)
if len(soap_header_elt) > 0:
envelope.append(soap_header_elt)
#
# body
#
soap_body = etree.SubElement(envelope,
'{%s}Body' % soaplib.ns_soap_env)
# instantiate the result message
result_message = descriptor.out_message()
# assign raw result to its wrapper, result_message
out_type = descriptor.out_message._type_info
if len(out_type) > 0:
if len(out_type) == 1:
attr_name = descriptor.out_message._type_info.keys()[0]
setattr(result_message, attr_name, result_raw)
else:
for i in range(len(out_type)):
attr_name = descriptor.out_message._type_info.keys()[i]
setattr(result_message, attr_name, result_raw[i])
# transform the results into an element
descriptor.out_message.to_xml(result_message, self.get_tns(),
soap_body)
# implementation hook
service.on_method_return(req_env, result_raw, soap_body,
http_resp_headers)
#
# misc
#
results_str = etree.tostring(envelope, xml_declaration=True,
encoding=string_encoding)
if descriptor.mtom:
http_resp_headers, results_str = apply_mtom(http_resp_headers,
results_str, descriptor.out_message._type_info,[result_raw])
# implementation hook
self.on_return(req_env, http_resp_headers, results_str)
# initiate the response
http_resp_headers['Content-Length'] = str(len(results_str))
start_response(HTTP_200, http_resp_headers.items())
if logger.level == logging.DEBUG:
logger.debug('\033[91m'+ "Response" + '\033[0m')
logger.debug(etree.tostring(envelope, xml_declaration=True,
pretty_print=True))
# return the serialized results
return [results_str]
def __call__(self, environ, start_response):
'''
This method conforms to the WSGI spec for callable wsgi applications (PEP 333).
This method looks in environ['wsgi.input'] for a fully formed soap request envelope,
will deserialize the request parameters and call the method on the object returned
by the getHandler() method.
@param the http environment
@param a callable that begins the response message
@returns the string representation of the soap call
'''
methodname = ''
try:
reset_request()
request.environ = environ
# implementation hook
self.onCall(environ)
serviceName = environ['PATH_INFO'].split('/')[-1]
service = self.getHandler(environ)
if serviceName.lower().endswith('wsdl'):
# get the wsdl for the service
#
# Assume path_info matches pattern
# /stuff/stuff/stuff/serviceName.wsdl or ?WSDL
#
serviceName = serviceName.split('.')[0]
url = reconstruct_url(environ).split('.wsdl')[0]
start_response('200 OK',[('Content-type','text/xml')])
try:
wsdl_content = service.wsdl(url)
# implementation hook
self.onWsdl(environ,wsdl_content)
except Exception, e:
# implementation hook
buffer = cStringIO.StringIO()
traceback.print_exc(file=buffer)
buffer.seek(0)
stacktrace = str(buffer.read())
faultStr = ElementTree.tostring(make_soap_fault( str(e), detail=stacktrace), encoding=string_encoding)
exceptions(faultStr)
self.onWsdlException(environ,e,faultStr)
# initiate the response
start_response('500',[('Content-type','text/xml'),('Content-length',str(len(faultStr)))])
return [faultStr]
reset_request()
return [wsdl_content]
if environ['REQUEST_METHOD'].lower() != 'post':
start_response('405 Method Not Allowed',[('Allow','POST')])
return ''
input = environ.get('wsgi.input')
length = environ.get("CONTENT_LENGTH")
body = input.read(int(length))
debug(body)
body = collapse_swa( environ.get("CONTENT_TYPE"), body)
# deserialize the body of the message
payload, header = from_soap(body)
methodname = payload.tag.split('}')[-1]
request.header = header
# call the method
func = getattr(service, methodname)
# retrieve the method descriptor
descriptor = func(_soap_descriptor=True)
params = descriptor.inMessage.from_xml(*[payload])
# implementation hook
self.onMethodExec(environ,body,params,descriptor.inMessage.params)
# call the method
retval = func(*params)
# transform the results into an element
# only expect a single element
results = None
if not (descriptor.isAsync or descriptor.isCallback):
results = descriptor.outMessage.to_xml(*[retval])
# implementation hook
self.onResults(environ,results,retval)
# grab any headers that were included in the request
response_headers = None
if hasattr(request,'response_headers'):
response_headers = request.response_headers
# construct the soap response, and serialize it
envelope = make_soap_envelope(results,tns=service.__tns__,header_elements=response_headers)
resp = ElementTree.tostring(envelope, encoding=string_encoding)
headers = {'Content-Type': 'text/xml'}
if descriptor.mtom:
headers, resp = apply_mtom( headers, resp,
descriptor.outMessage.params,
(retval,) )
if environ.has_key('CONTENT_LENGTH'):
del(environ['CONTENT_LENGTH'])
# initiate the response
start_response('200 OK',headers.items())
self.onReturn(environ,resp)
debug(resp)
# return the serialized results
reset_request()
return [resp]
def __handle_soap_request(self, req_env, start_response, url):
http_resp_headers = {
'Content-Type': 'text/xml',
'Content-Length': '0',
}
method_name = None
try:
# implementation hook
self.on_call(req_env)
if req_env['REQUEST_METHOD'].lower() != 'post':
http_resp_headers['Allow'] = 'POST'
start_response(HTTP_405, http_resp_headers.items())
return ['']
input = req_env.get('wsgi.input')
length = req_env.get("CONTENT_LENGTH")
body = input.read(int(length))
try:
service = None
soap_req_header, soap_req_payload = self.__decode_soap_request(
req_env, body)
self.validate_request(soap_req_payload)
method_name = self.__get_method_name(req_env, soap_req_payload)
if method_name is None:
resp = "Could not get method name!"
http_resp_headers['Content-Length'] = str(len(resp))
start_response(HTTP_500, http_resp_headers.items())
return [resp]
service_class = self.get_service_class(method_name)
service = self.get_service(service_class, req_env)
finally:
# for performance reasons, we don't want the following to run
# in production even if we don't see the results.
if logger.level == logging.DEBUG:
try:
logger.debug(etree.tostring(etree.fromstring(body),
pretty_print=True))
except:
logger.debug(body)
raise
# retrieve the method descriptor
descriptor = service.get_method(method_name)
func = getattr(service, descriptor.name)
# decode header object
if soap_req_header is not None and len(soap_req_header) > 0:
service.soap_in_header = descriptor.in_header.from_xml(soap_req_header)
# decode method arguments
if soap_req_payload is not None and len(soap_req_payload) > 0:
params = descriptor.in_message.from_xml(soap_req_payload)
else:
params = [None] * len(descriptor.in_message._type_info)
# implementation hook
service.on_method_call(req_env, method_name, params, soap_req_payload)
# call the method
result_raw = service.call_wrapper(func, params)
# create result message
result_message = descriptor.out_message()
# assign raw result to its wrapper, result_message
out_type = descriptor.out_message._type_info
if len(out_type) > 0:
assert len(out_type) == 1
attr_name = descriptor.out_message._type_info.keys()[0]
setattr(result_message, attr_name, result_raw)
# transform the results into an element
# only expect a single element
soap_resp_body = None
if not (descriptor.is_async or descriptor.is_callback):
soap_resp_body = descriptor.out_message.to_xml(result_message,
self.get_tns())
soap_resp_header = None
if not (descriptor.out_header is None or service.soap_out_header is None):
soap_resp_header = descriptor.out_header.to_xml(
service.soap_out_header, self.get_tns(),
descriptor.out_header.get_type_name())
# implementation hook
service.on_method_return(req_env, result_raw, soap_resp_body,
http_resp_headers)
# construct the soap response, and serialize it
envelope = make_soap_envelope(soap_resp_header, soap_resp_body)
results_str = etree.tostring(envelope, xml_declaration=True,
encoding=string_encoding)
if descriptor.mtom:
http_resp_headers, results_str = apply_mtom(http_resp_headers,
results_str,descriptor.out_message._type_info,[result_raw])
# implementation hook
self.on_return(req_env, http_resp_headers, results_str)
# initiate the response
http_resp_headers['Content-Length'] = str(len(results_str))
start_response(HTTP_200, http_resp_headers.items())
if logger.level == logging.DEBUG:
logger.debug('\033[91m'+ "Response" + '\033[0m')
logger.debug(etree.tostring(envelope, xml_declaration=True,
pretty_print=True))
# return the serialized results
return [results_str]
# The user issued a Fault, so handle it just like an exception!
except Fault, e:
stacktrace=traceback.format_exc()
logger.error(stacktrace)
# FIXME: There's no way to alter soap response headers for the user.
soap_resp_header = None
soap_resp_body = Fault.to_xml(e, self.get_tns())
fault_xml = make_soap_envelope(soap_resp_header, soap_resp_body)
fault_str = etree.tostring(fault_xml, xml_declaration=True,
encoding=string_encoding)
if logger.level == logging.DEBUG:
logger.debug(etree.tostring(etree.fromstring(fault_str),
pretty_print=True))
# implementation hook
if not (service is None):
service.on_method_exception(req_env, e, fault_xml, fault_str)
self.on_exception(req_env,e,fault_str)
# initiate the response
http_resp_headers['Content-Length'] = str(len(fault_str))
start_response(HTTP_500, http_resp_headers.items())
return [fault_str]
class SOAPService(BaseHandler, SoapServiceBase):
'''
This is the base object representing a soap web application, and conforms
to the WSGI specification (PEP 333). This object should be overridden
and getHandler(environ) overridden to provide the object implementing
the specified functionality. Hooks have been added so that the subclass
can react to various events that happen durring the execution of the
request.
'''
def __init__(self, application, request, **kwargs):
setattr(self, "request", request)
setattr(self, "application", application)
BaseHandler.__init__(self, application, request, **kwargs)
SoapServiceBase.__init__(self)
def onCall(self, environ):
'''
This is the first method called when this WSGI app is invoked
@param the wsgi environment
'''
pass
def onWsdl(self, environ, wsdl):
'''
This is called when a wsdl is requested
@param the wsgi environment
@param the wsdl string
'''
pass
def onWsdlException(self, environ, exc, resp):
'''
Called when an exception occurs durring wsdl generation
@param the wsgi environment
@param exc the exception
@param the fault response string
'''
pass
def onMethodExec(self, environ, body, py_params, soap_params):
'''
Called BEFORE the service implementing the functionality is called
@param the wsgi environment
@param the body element of the soap request
@param the tuple of python params being passed to the method
@param the soap elements for each params
'''
pass
def onResults(self, environ, py_results, soap_results):
'''
Called AFTER the service implementing the functionality is called
@param the wsgi environment
@param the python results from the method
@param the xml serialized results of the method
'''
pass
def onException(self, environ, exc, resp):
'''
Called when an error occurs durring execution
@param the wsgi environment
@param the exception
@param the response string
'''
pass
def onReturn(self, environ, returnString):
'''
Called before the application returns
@param the wsgi environment
@param return string of the soap request
'''
pass
def getHandler(self, environ):
'''
This method returns the object responsible for processing a given request, and
needs to be overridden by a subclass to handle the application specific
mapping of the request to the appropriate handler.
@param the wsgi environment
@returns the object to be called for the soap operation
'''
return self
def post(self):
'''
This method conforms to the WSGI spec for callable wsgi applications (PEP 333).
This method looks in environ['wsgi.input'] for a fully formed soap request envelope,
will deserialize the request parameters and call the method on the object returned
by the getHandler() method.
@param the http environment
@param a callable that begins the response message
@returns the string representation of the soap call
'''
methodname = ''
container = tornado.wsgi.WSGIContainer(self.application)
environ = container.environ(self.request)
try:
# implementation hook
self.onCall(environ)
serviceName = environ['PATH_INFO'].split('/')[-1]
service = self.getHandler(environ)
if (environ['QUERY_STRING'].endswith('wsdl')
or environ['PATH_INFO'].endswith('wsdl')
) and environ['REQUEST_METHOD'].lower() == 'get':
# get the wsdl for the service
#
# Assume path_info matches pattern
# /stuff/stuff/stuff/serviceName.wsdl or ?WSDL
#
serviceName = serviceName.split('.')[0]
url = reconstruct_url(environ).split('.wsdl')[0]
try:
wsdl_content = service.wsdl(url)
# implementation hook
self.onWsdl(environ, wsdl_content)
except Exception, e:
# implementation hook
buffer = cStringIO.StringIO()
traceback.print_exc(file=buffer)
buffer.seek(0)
stacktrace = str(buffer.read())
faultStr = ElementTree.tostring(make_soap_fault(
str(e), detail=stacktrace),
encoding=string_encoding)
exceptions(faultStr)
self.onWsdlException(environ, e, faultStr)
# initiate the response
#return Response(faultStr, '500 Internal Server Error', [('Content-type','text/xml;charset=utf-8')])
self.set_header('Content-Type', 'text/xml;charset=utf-8')
return self.write(faultStr)
#return Response(wsdl_content, '200 OK', [('Content-type','text/xml;charset=utf-8')])
self.set_header('Content-Type', 'text/xml;charset=utf-8')
return self.write(wsdl_content)
if environ['REQUEST_METHOD'].lower() != 'post':
#return Response('', '405 Method Not Allowed',[('Allow','POST')])
self.set_header('Content-Type', 'text/html;charset=utf-8')
return self.write_error(status_code=405)
input = environ.get('wsgi.input')
length = environ.get("CONTENT_LENGTH")
body = input.read(int(length))
debug(body)
# body, _unmentioned_attachs = collapse_swa( environ.get("CONTENT_TYPE"), body)
# collapse_swa has some problem
try:
body, _unmentioned_attachs = collapse_swa(
environ.get("CONTENT_TYPE"), body)
except:
body = collapse_swa(environ.get("CONTENT_TYPE"), body)
_unmentioned_attachs = []
pass
# deserialize the body of the message
try:
payload, header = from_soap(body)
except SyntaxError, e:
payload = None
header = None
if payload is not None:
methodname = payload.tag.split('}')[-1]
else:
# check HTTP_SOAPACTION
methodname = environ.get("HTTP_SOAPACTION")
if methodname.startswith('"') and methodname.endswith('"'):
methodname = methodname[1:-1]
if methodname.find('/') > 0:
methodname = methodname.split('/')[1]
# call the method
func = getattr(service, methodname)
# retrieve the method descriptor
descriptor = func(_soap_descriptor=True, klazz=service.__class__)
if payload is not None:
params = descriptor.inMessage.from_xml(*[payload])
else:
params = ()
# implementation hook
self.onMethodExec(environ, body, params,
descriptor.inMessage.params)
# call the method
if len(_unmentioned_attachs) > 0:
retval = func(*params,
unmentioned_attachs=_unmentioned_attachs)
else:
retval = func(*params)
# transform the results into an element
# only expect a single element
results = None
if not (descriptor.isAsync or descriptor.isCallback):
results = descriptor.outMessage.to_xml(*[retval])
# implementation hook
self.onResults(environ, results, retval)
# construct the soap response, and serialize it
envelope = make_soap_envelope(results, tns=service.__tns__)
#ElementTree.cleanup_namespaces(envelope)
resp = ElementTree.tostring(envelope, encoding=string_encoding)
headers = {'Content-Type': 'text/xml;charset=utf-8'}
if descriptor.mtom:
headers, resp = apply_mtom(headers, resp,
descriptor.outMessage.params,
(retval, ))
resp = '<?xml version="1.0" encoding="utf-8"?>' + resp
if environ.has_key('CONTENT_LENGTH'):
del (environ['CONTENT_LENGTH'])
self.onReturn(environ, resp)
debug(resp)
# return the serialized results
#return Response(resp, '200 OK', headers.items())
self.set_header('Content-Type', 'text/xml;charset=utf-8')
return self.write(resp)
