def test_local_serialize_schema(self):
from ZSI import SoapWriter
from ZSI import _child_elements
from xml.dom.ext.reader import PyExpat
msg = self.client_module.DSQueryRegistrySoapOut()
msg.DSQueryRegistryResult = msg.new_DSQueryRegistryResult()
msg.DSQueryRegistryResult.Any = 'hi'
input = open('wsdl/nvo-admin.wsdl').read()
reader = PyExpat.Reader()
dom = reader.fromString(input)
dnode = _child_elements(dom)[0]
tnode = _child_elements(dnode)[0]
snode = _child_elements(tnode)[0]
msg.DSQueryRegistryResult.Schema = snode
sw = SoapWriter()
sw.serialize(msg)
soap = str(sw)
print(soap)
ps = ParsedSoap(soap)
pyobj = ps.Parse(msg.typecode)
self.assertEqual(pyobj.DSQueryRegistryResult.Any,
msg.DSQueryRegistryResult.Any)
self.assertTrue(_is_element(pyobj.DSQueryRegistryResult.Schema))
print(_get_element_nsuri_name(pyobj.DSQueryRegistryResult.Schema))
self.assertEqual(
_get_element_nsuri_name(pyobj.DSQueryRegistryResult.Schema),
('http://www.w3.org/2001/XMLSchema', 'schema'))
def test_local_serialize_schema(self):
from ZSI import SoapWriter
from ZSI import _child_elements
from xml.dom.ext.reader import PyExpat
msg = self.client_module.DSQueryRegistrySoapOut()
msg.DSQueryRegistryResult = msg.new_DSQueryRegistryResult()
msg.DSQueryRegistryResult.Any = 'hi'
input = open('wsdl/nvo-admin.wsdl').read()
reader = PyExpat.Reader()
dom = reader.fromString(input)
dnode = _child_elements(dom)[0]
tnode = _child_elements(dnode)[0]
snode = _child_elements(tnode)[0]
msg.DSQueryRegistryResult.Schema = snode
sw = SoapWriter()
sw.serialize(msg)
soap = str(sw)
print soap
ps = ParsedSoap(soap)
pyobj = ps.Parse(msg.typecode)
self.failUnlessEqual(pyobj.DSQueryRegistryResult.Any, msg.DSQueryRegistryResult.Any)
self.failUnless(_is_element(pyobj.DSQueryRegistryResult.Schema))
print _get_element_nsuri_name(pyobj.DSQueryRegistryResult.Schema)
self.failUnlessEqual(_get_element_nsuri_name(pyobj.DSQueryRegistryResult.Schema), (u'http://www.w3.org/2001/XMLSchema', u'schema'))
def test_local_anyType(self):
"""rpc/lit, testing if <any/> lax content handling
should get back dicts and strings
"""
ps = ParsedSoap(MSG)
pyobj = ps.Parse(self.client_module.EventApproximatesSoapOut.typecode)
any = {'PoolTotals': {'Pool': {'Total': u'4117.66', 'ENumbers': None, 'JackpotNet': None}}, 'Approximates': {'Pool': {'Win': u'3.90,0.00,10.40,11.80,4.70,29.50,29.90,2.40,19.80,0.00', 'Place': u'1.04,0.00,2.80,5.90,2.00,5.20,7.40,1.04,4.00,0.00'}}}
self.failUnless(pyobj.EventApproximatesResult.Any == any, 'Failed match:\n %s\n\n%s' %(
pyobj.EventApproximatesResult.Any, any))
pyobj.EventApproximatesResult.Any = dict(pyobj.EventApproximatesResult.Any)
sw = SoapWriter()
sw.serialize(pyobj)
print str(sw)
ps2 = ParsedSoap(str(sw))
pyobj2 = ps.Parse(self.client_module.EventApproximatesSoapOut.typecode)
print "EAR: ", pyobj2.EventApproximatesResult
print "Any: ", pyobj2.EventApproximatesResult.Any
self.failUnless(pyobj.EventApproximatesResult.Any == pyobj2.EventApproximatesResult.Any,
'Failed match:\n %s\n\n%s' %(pyobj.EventApproximatesResult.Any, pyobj2.EventApproximatesResult.Any))
def check_any_dict_list_rpcenc(self):
sw = SoapWriter()
testObj = [{"a":1,"b":2}, {"d":4,"e":5}, {"f":{"x":9}, "g":[6,7.0]}]
typecode = TC.Any(aslist=True)
sw.serialize(testObj, typecode=typecode)
xml = str(sw)
ps = ParsedSoap(xml)
result = TC.Any().parse(ps.body_root, ps)
self.failUnless(result == testObj)
def check_any_dict_list_rpcenc(self):
sw = SoapWriter()
testObj = [{"a":1,"b":2}, {"d":4,"e":5}, {"f":{"x":9}, "g":[6,7.0]}]
typecode = TC.Any(aslist=True)
sw.serialize(testObj, typecode=typecode)
xml = str(sw)
ps = ParsedSoap(xml)
result = TC.Any().parse(ps.body_root, ps)
self.assertTrue(result == testObj)
def check_parse_empty_string(self):
# Empty String
typecodes = list(TC.Any.parsemap.values())
for tc in [c for c in list(TC.Any.parsemap.values()) if isinstance(c, TC.String)]:
sw = SoapWriter()
sw.serialize("", typecode=tc, typed=True)
soap = str(sw)
ps = ParsedSoap(soap)
parsed = ps.Parse(TC.Any())
self.assertEqual("", parsed)
def lather(obj, tc=None):
''' Serial a python object into SOAP, return the SOAP.
If tc is None, expect obj to have a .typecode attribute.
'''
if tc is None:
tc = obj.typecode
IO = StringIO()
S = SoapWriter(IO)
S.serialize(obj, tc)
return str(S)
def check_parse_empty_string(self):
# Empty String
typecodes = list(TC.Any.parsemap.values())
for tc in [c for c in list(TC.Any.parsemap.values()) if isinstance(c, TC.String)]:
sw = SoapWriter()
sw.serialize("", typecode=tc, typed=True)
soap = str(sw)
ps = ParsedSoap(soap)
parsed = ps.Parse(TC.Any())
self.assertEqual("", parsed)
def check_parse_empty_all(self):
# None
skip = [TC.FPEnumeration, TC.Enumeration, TC.IEnumeration, TC.List, TC.Integer]
for typeclass in [c for c in list(TC.__dict__.values()) if type(c) in [type,type] and not issubclass(c, TC.String) and issubclass(c, TC.SimpleType)]:
if typeclass in skip: continue
tc = typeclass()
sw = SoapWriter()
sw.serialize(None, typecode=tc, typed=True)
soap = str(sw)
ps = ParsedSoap(soap)
parsed = ps.Parse(TC.Any())
self.assertEqual(None, parsed)
def check_parse_empty_all(self):
# None
skip = [TC.FPEnumeration, TC.Enumeration, TC.IEnumeration, TC.List, TC.Integer]
for typeclass in [c for c in list(TC.__dict__.values()) if type(c) in [type,type] and not issubclass(c, TC.String) and issubclass(c, TC.SimpleType)]:
if typeclass in skip: continue
tc = typeclass()
sw = SoapWriter()
sw.serialize(None, typecode=tc, typed=True)
soap = str(sw)
ps = ParsedSoap(soap)
parsed = ps.Parse(TC.Any())
self.assertEqual(None, parsed)
def test_local_generateMessageAttachment(self):
"""doc/lit, generating a message using MIME attachment,
we don't have the server side implementation so we can
really do a full test yet
"""
from TestService_server import uploadFileRequest
#stubs were properly generated
request = uploadFileRequest()
request._name = "TestService_client.py"
request._attachment = open("stubs/TestService_client.py", 'r')
sw = SoapWriter({}, header=True, outputclass=None, encodingStyle=None)
sw.serialize(request)
print "the request message is: " + str(sw)
def test_local_generateMessageAttachment(self):
"""doc/lit, generating a message using MIME attachment,
we don't have the server side implementation so we can
really do a full test yet
"""
from TestService_server import uploadFileRequest
#stubs were properly generated
request = uploadFileRequest()
request._name = "TestService_client.py"
request._attachment = open("stubs/TestService_client.py", 'r')
sw = SoapWriter({}, header=True, outputclass=None, encodingStyle=None)
sw.serialize(request)
print "the request message is: " + str(sw)
def newFunc(kw):
try:
log("%s(%s)\n" % (str(oldFunc.__name__), str(kw)))
kw = trans.transArgs(oldFunc.__name__, kw)
res = oldFunc(**kw)
res = fixObject(res)
log("%s(%s) -> %s\n" % (str(oldFunc.__name__), str(kw), str(res)))
sw = SoapWriter()
sw.serialize(res, res.typecode)
res = trans.transResult(oldFunc.__name__,
minidom.parseString(str(sw)))
return res
except:
log("%s\n" % (traceback.format_exc(sys.exc_info())))
raise
def setBody(self, body, title='', is_error=0, bogus_str_search=None):
if isinstance(body, Fault):
# Convert Fault object to SOAP response.
body = body.AsSOAP()
else:
# Marshall our body as an SOAP response. Strings will be sent
# strings, integers as integers, etc. We do *not* convert
# everything to a string first.
try:
target = self._method
body = premarshal(body)
result = body
if hasattr(result, 'typecode'):
tc = result.typecode
else:
tc = TC.Any(aslist=1, pname=target + 'Response')
result = [result]
sw = SoapWriter(nsdict={}, header=True, outputclass=None,
encodingStyle=None)
body = str(sw.serialize(result, tc))
Node.unlink(sw.dom.node)
Node.unlink(sw.body.node)
del sw.dom.node
del sw.body.node
del sw.dom
del sw.body
except:
self.exception()
return
# Set our body to the message, and fix our MIME type.
self._real.setBody(body)
self._setHeader()
return self
def serializeRequest(request):
tc = getattr(request, 'typecode', None)
sw = SoapWriter(nsdict={},
header=True,
outputclass=None,
encodingStyle=None)
return str(sw.serialize(request, tc))
def _cache_soap(self, name, res):
from ZSI import SoapWriter
sw = SoapWriter()
xml = str(sw.serialize(res))
self._soapcache[name] = xml
# hack to get the cache to save
self._soapcache = self._soapcache
def deserialize(objectToDeserialize):
sw = SoapWriter(nsdict={}, header=True, outputclass=None,
encodingStyle=None)
tc = TC.Any(pname=None, aslist=False)
deserializedObject = sw.serialize(objectToDeserialize, tc).body
root = etree.XML(str(deserializedObject))
body = root[0]
return etree.tostring(body, encoding='utf-8', pretty_print=True)
def test_local_anyType(self):
"""rpc/lit, testing if <any/> lax content handling
should get back dicts and strings
"""
ps = ParsedSoap(MSG)
pyobj = ps.Parse(self.client_module.EventApproximatesSoapOut.typecode)
any = {
'PoolTotals': {
'Pool': {
'Total': u'4117.66',
'ENumbers': None,
'JackpotNet': None
}
},
'Approximates': {
'Pool': {
'Win':
u'3.90,0.00,10.40,11.80,4.70,29.50,29.90,2.40,19.80,0.00',
'Place':
u'1.04,0.00,2.80,5.90,2.00,5.20,7.40,1.04,4.00,0.00'
}
}
}
self.failUnless(
pyobj.EventApproximatesResult.Any == any,
'Failed match:\n %s\n\n%s' %
(pyobj.EventApproximatesResult.Any, any))
pyobj.EventApproximatesResult.Any = dict(
pyobj.EventApproximatesResult.Any)
sw = SoapWriter()
sw.serialize(pyobj)
print str(sw)
ps2 = ParsedSoap(str(sw))
pyobj2 = ps.Parse(self.client_module.EventApproximatesSoapOut.typecode)
print "EAR: ", pyobj2.EventApproximatesResult
print "Any: ", pyobj2.EventApproximatesResult.Any
self.failUnless(
pyobj.EventApproximatesResult.Any ==
pyobj2.EventApproximatesResult.Any,
'Failed match:\n %s\n\n%s' % (pyobj.EventApproximatesResult.Any,
pyobj2.EventApproximatesResult.Any))
def _cache_soap(self, name, res):
from ZSI import SoapWriter
sw = SoapWriter()
xml = str(sw.serialize(res))
self._soapcache[name] = xml
# hack to get the cache to save
self._soapcache = self._soapcache
def check_uri_quoting(self):
""" all reserved characters used for reserved purpose.
"""
sw1 = SoapWriter(envelope=False)
tc1 = TC.URI("sourceforge")
orig = "https://sourceforge.net/tracker/index.php?func=detail&aid=1520092&group_id=26590&atid=387667"
sw1.serialize(orig, typecode=tc1, typed=False)
s1 = str(sw1)
sw2 = SoapWriter(envelope=False)
tc2 = TC.String("sourceforge")
sw2.serialize(orig, typecode=tc2, typed=False)
s2 = str(sw2)
# print s1
# print s2
self.failUnless(s1 == s2, "reserved characters used for reserved purpose should not be escaped.")
ps = ParsedSoap(s2, envelope=False)
pyobj = ps.Parse(tc2)
self.failUnless(pyobj == orig, "parsed object should be equivalent to original")
def check_builtins(self):
myInt,myLong,myStr,myDate,myFloat = 123,2147483648,\
"hello", time.gmtime(), 1.0001
orig = [myInt, myLong, myStr, myDate, myFloat]
sw = SoapWriter()
sw.serialize(orig, typecode=TC.Any(pname="builtins", aslist=True))
ps = ParsedSoap(str(sw))
parsed = ps.Parse(TC.Any())
self.assertEqual(len(orig), len(parsed))
self.assertEqual(myInt, parsed[0])
self.assertEqual(myLong, parsed[1])
self.assertEqual(myStr, parsed[2])
self.assertEqual(myDate[0:6], parsed[3][0:6])
self.assertEqual(myFloat, parsed[4])
self.assertEqual(type(myInt), type(parsed[0]))
self.assertEqual(type(myLong), type(parsed[1]))
self.assertEqual(type(myStr), type(parsed[2]))
self.assertEqual(tuple, type(parsed[3]))
self.assertEqual(type(myFloat), type(parsed[4]))
def check_builtins(self):
myInt,myLong,myStr,myDate,myFloat = 123,2147483648,\
"hello", time.gmtime(), 1.0001
orig = [myInt,myLong,myStr,myDate,myFloat]
sw = SoapWriter()
sw.serialize(orig, typecode=TC.Any(pname="builtins", aslist=True))
ps = ParsedSoap(str(sw))
parsed = ps.Parse(TC.Any())
self.assertEqual(len(orig), len(parsed))
self.assertEqual(myInt, parsed[0])
self.assertEqual(myLong, parsed[1])
self.assertEqual(myStr, parsed[2])
self.assertEqual(myDate[0:6], parsed[3][0:6])
self.assertEqual(myFloat, parsed[4])
self.assertEqual(type(myInt), type(parsed[0]))
self.assertEqual(type(myLong), type(parsed[1]))
self.assertEqual(type(myStr), type(parsed[2]))
self.assertEqual(tuple, type(parsed[3]))
self.assertEqual(type(myFloat), type(parsed[4]))
def checkt7(self):
ps = ParsedSoap(text)
tcdict = TC.Apache.Map('c-gensym1')
tclist = TC.Apache.Map('c-gensym1', aslist=1)
d = tcdict.parse(ps.body_root, ps)
self.assertEqual(d, {u'a': 123, '\x00\x01': 456})
#print 'as dictionary\n', d
l = tclist.parse(ps.body_root, ps)
self.assertEqual(l, [('\x00\x01', 456), (u'a', 123)])
#print '\n', '=' * 30
#print 'as list\n', l
#print '\n', '=' * 30
sw = SoapWriter()
sw.serialize(d, tcdict)
#print >>sys.stdout, sw
#print '\n', '=' * 30
sw = SoapWriter()
sw.serialize(l, tclist)
def checkt7(self):
ps = ParsedSoap(text)
tcdict = TC.Apache.Map('c-gensym1')
tclist = TC.Apache.Map('c-gensym1', aslist=1)
d = tcdict.parse(ps.body_root, ps)
self.assertEqual(d, { u'a':123, '\x00\x01':456 })
#print 'as dictionary\n', d
l = tclist.parse(ps.body_root, ps)
self.assertEqual(l, [('\x00\x01', 456), (u'a', 123)])
#print '\n', '=' * 30
#print 'as list\n', l
#print '\n', '=' * 30
sw = SoapWriter()
sw.serialize(d, tcdict)
#print >>sys.stdout, sw
#print '\n', '=' * 30
sw = SoapWriter()
sw.serialize(l, tclist)
def processResponse(cls, output, **kw):
sw = SoapWriter(outputclass=cls.writerClass)
sw.serialize(output)
return sw
def Send(self, url, opname, obj, nsdict=None, soapaction=None, **kw):
'''Send a message. If url is None, use the value from the
constructor (else error). obj is the object (data) to send.
Data may be described with a requesttypecode keyword, or a
requestclass keyword; default is the class's typecode (if
there is one), else Any.
'''
# Get the TC for the obj.
if kw.has_key('requesttypecode'):
tc = kw['requesttypecode']
elif kw.has_key('requestclass'):
tc = kw['requestclass'].typecode
elif type(obj) == types.InstanceType:
tc = getattr(obj.__class__, 'typecode')
if tc is None: tc = TC.Any(opname, aslist=1)
else:
tc = TC.Any(opname, aslist=1)
if self.op_ns:
opname = '%s:%s' % (self.op_ns, opname)
tc.oname = opname
# Determine the SOAP auth element.
if kw.has_key('auth_header'):
auth_header = kw['auth_header']
elif self.auth_style & AUTH.zsibasic:
auth_header = _AuthHeader % (self.auth_user, self.auth_pass)
else:
auth_header = None
# Serialize the object.
s = StringIO.StringIO()
d = self.nsdict or {}
if self.ns: d[''] = self.ns
d.update(nsdict or self.nsdict or {})
sw = SoapWriter(s, nsdict=d, header=auth_header)
if kw.has_key('_args'):
sw.serialize(kw['_args'], tc)
else:
sw.serialize(obj, tc, typed=0)
sw.close()
soapdata = s.getvalue()
# Tracing?
if self.trace:
print >>self.trace, "_" * 33, time.ctime(time.time()), "REQUEST:"
print >>self.trace, soapdata
# Send the request.
# host and port may be parsed from a WSDL file. if they are, they
# are most likely unicode format, which httplib does not care for
if isinstance(self.host, unicode):
self.host = str(self.host)
if not isinstance(self.port, int):
self.port = int(self.port)
if not self.ssl:
self.h = httplib.HTTPConnection(self.host, self.port)
else:
self.h = httplib.HTTPSConnection(self.host, self.port,
**self.ssl_files)
self.h.connect()
self.h.putrequest("POST", url or self.url)
self.h.putheader("Content-length", "%d" % len(soapdata))
self.h.putheader("Content-type", 'text/xml; charset=utf-8')
SOAPActionValue = '"%s"' % (soapaction or self.soapaction)
self.h.putheader("SOAPAction", SOAPActionValue)
if self.auth_style & AUTH.httpbasic:
val = _b64_encode(self.auth_user + ':' + self.auth_pass) \
.replace("\012", "")
self.h.putheader('Authorization', 'Basic ' + val)
for header,value in self.user_headers:
self.h.putheader(header, value)
self.h.endheaders()
self.h.send(soapdata)
# Clear prior receive state.
self.data, self.ps = None, None
def register_results(algsynonim, password, pocketid, results):
"""Posts results to the poligon server"""
register_request = RegisterResultSoapIn()
register_request.AlgSynonim = algsynonim
register_request.Password = password
register_request.PocketKey = int(pocketid)
register_request.LearnResults = register_request.new_learnResults()
register_request.TestResults = register_request.new_testResults()
for i in range(len(results)):
test_result = register_request.TestResults.new_TestResult()
learn_result = register_request.LearnResults.new_TestResult()
test_result.Index = i
learn_result.Index = i
test_result.Error = results[i].Error
test_result.ErrorException = results[i].ErrorException
learn_result.Error = results[i].Error
learn_result.ErrorException = results[i].ErrorException
if not results[i].Error:
test_result.Error = results[i].Test.Error
test_result.ErrorException = results[i].Test.ErrorException
learn_result.Error = results[i].Test.Error
learn_result.ErrorException = results[i].Test.ErrorException
# Answers
test_result.Answers = test_result.new_Answers()
learn_result.Answers = learn_result.new_Answers()
for j in range(len(results[i].Learn.Targets)):
learn_result.Answers.Int.append(int(results[i].Learn.Targets[j]))
for j in range(len(results[i].Test.Targets)):
test_result.Answers.Int.append(int(results[i].Test.Targets[j]))
# PropertiesWeights
#test_result.PropertiesWeights = test_result.new_PropertiesWeights()
#learn_result.PropertiesWeights = learn_result.new_PropertiesWeights()
#for j in range(len(results[i].LearnPropertiesWeights)):
# learn_result.PropertiesWeights.Double.append(results[i].LearnPropertiesWeights[j])
#for j in range(len(results[i].TestPropertiesWeights)):
# test_result.PropertiesWeights.Double.append(results[i].TestPropertiesWeights[j])
# Object weights
#test_result.ObjectsWeights = test_result.new_ObjectsWeights()
#learn_result.ObjectsWeights = learn_result.new_ObjectsWeights()
#for j in range(len(results[i].LearnObjectsWeights)):
# learn_result.ObjectsWeights.Double.append(results[i].LearnObjectsWeights[j])
#for j in range(len(results[i].TestObjectsWeights)):
# test_result.ObjectsWeights.Double.append(results[i].TestObjectsWeights[j])
# ProbabilityMatrix
test_result.ProbabilityMatrix = test_result.new_ProbabilityMatrix()
learn_result.ProbabilityMatrix = learn_result.new_ProbabilityMatrix()
for vector in results[i].Test.ProbabilityMatrix:
array = test_result.ProbabilityMatrix.new_ArrayOfDouble()
for item in vector:
array.Double.append(item)
test_result.ProbabilityMatrix.ArrayOfDouble.append(array)
for vector in results[i].Learn.ProbabilityMatrix:
array = learn_result.ProbabilityMatrix.new_ArrayOfDouble()
for item in vector:
array.Double.append(item)
learn_result.ProbabilityMatrix.ArrayOfDouble.append(array)
register_request.TestResults.TestResult.append(test_result)
register_request.LearnResults.TestResult.append(learn_result)
try:
sw = SoapWriter()
sw.serialize(register_request)
file = open('RegisterResult.xml', 'w')
file.write(str(sw))
file.close()
except:
logger.error('Can\'t write file results file')
if REGISTER_RESULTS:
try:
response = service.RegisterResult(register_request, **KW)
if response.RegisterResultResult.Status == 'Ok':
logger.info('Results are posted successfully')
else:
logger.error(
'Error occured while posting results\n{0}'.format(response.RegisterResultResult.Message.encode('unicode', 'replace')))
return response.RegisterResultResult
except:
logger.error(
'Error occured while posting results \'{0}\'\n{1}'.format(pocketid, sys.exc_info()[0]))
return None
def Send(self, url, opname, obj, nsdict={}, soapaction=None, wsaction=None,
endPointReference=None, soapheaders=(), **kw):
'''Send a message. If url is None, use the value from the
constructor (else error). obj is the object (data) to send.
Data may be described with a requesttypecode keyword, the default
is the class's typecode (if there is one), else Any.
Try to serialize as a Struct, if this is not possible serialize an Array. If
data is a sequence of built-in python data types, it will be serialized as an
Array, unless requesttypecode is specified.
arguments:
url --
opname -- struct wrapper
obj -- python instance
key word arguments:
nsdict --
soapaction --
wsaction -- WS-Address Action, goes in SOAP Header.
endPointReference -- set by calling party, must be an
EndPointReference type instance.
soapheaders -- list of pyobj, typically w/typecode attribute.
serialized in the SOAP:Header.
requesttypecode --
'''
url = url or self.url
endPointReference = endPointReference or self.endPointReference
# Serialize the object.
d = {}
d.update(self.nsdict)
d.update(nsdict)
sw = SoapWriter(nsdict=d, header=True, outputclass=self.writerclass,
encodingStyle=kw.get('encodingStyle'),)
requesttypecode = kw.get('requesttypecode')
if kw.has_key('_args'): #NamedParamBinding
tc = requesttypecode or TC.Any(pname=opname, aslist=False)
sw.serialize(kw['_args'], tc)
elif not requesttypecode:
tc = getattr(obj, 'typecode', None) or TC.Any(pname=opname, aslist=False)
try:
if type(obj) in _seqtypes:
obj = dict(map(lambda i: (i.typecode.pname,i), obj))
except AttributeError:
# can't do anything but serialize this in a SOAP:Array
tc = TC.Any(pname=opname, aslist=True)
else:
tc = TC.Any(pname=opname, aslist=False)
sw.serialize(obj, tc)
else:
sw.serialize(obj, requesttypecode)
for i in soapheaders:
sw.serialize_header(i)
#
# Determine the SOAP auth element. SOAP:Header element
if self.auth_style & AUTH.zsibasic:
sw.serialize_header(_AuthHeader(self.auth_user, self.auth_pass),
_AuthHeader.typecode)
#
# Serialize WS-Address
if self.wsAddressURI is not None:
if self.soapaction and wsaction.strip('\'"') != self.soapaction:
raise WSActionException, 'soapAction(%s) and WS-Action(%s) must match'\
%(self.soapaction,wsaction)
self.address = Address(url, self.wsAddressURI)
self.address.setRequest(endPointReference, wsaction)
self.address.serialize(sw)
#
# WS-Security Signature Handler
if self.sig_handler is not None:
self.sig_handler.sign(sw)
scheme,netloc,path,nil,nil,nil = urlparse.urlparse(url)
transport = self.transport
if transport is None and url is not None:
if scheme == 'https':
transport = self.defaultHttpsTransport
elif scheme == 'http':
transport = self.defaultHttpTransport
else:
raise RuntimeError, 'must specify transport or url startswith https/http'
# Send the request.
if issubclass(transport, httplib.HTTPConnection) is False:
raise TypeError, 'transport must be a HTTPConnection'
soapdata = str(sw)
self.h = transport(netloc, None, **self.transdict)
self.h.connect()
self.SendSOAPData(soapdata, url, soapaction, **kw)
def _Dispatch(ps, modules, SendResponse, SendFault, nsdict={}, typesmodule=None,
gettypecode=gettypecode, rpc=False, docstyle=False, **kw):
'''Find a handler for the SOAP request in ps; search modules.
Call SendResponse or SendFault to send the reply back, appropriately.
Behaviors:
default -- Call "handler" method with pyobj representation of body root, and return
a self-describing request (w/typecode). Parsing done via a typecode from
typesmodule, or Any.
docstyle -- Call "handler" method with ParsedSoap instance and parse result with an
XML typecode (DOM). Behavior, wrap result in a body_root "Response" appended message.
rpc -- Specify RPC wrapper of result. Behavior, ignore body root (RPC Wrapper)
of request, parse all "parts" of message via individual typecodes. Expect
the handler to return the parts of the message, whether it is a dict, single instance,
or a list try to serialize it as a Struct but if this is not possible put it in an Array.
Parsing done via a typecode from typesmodule, or Any.
'''
global _client_binding
try:
what = str(ps.body_root.localName)
# See what modules have the element name.
if modules is None:
modules = ( sys.modules['__main__'], )
handlers = [ getattr(m, what) for m in modules if hasattr(m, what) ]
if len(handlers) == 0:
raise TypeError("Unknown method " + what)
# Of those modules, see who's callable.
handlers = [ h for h in handlers if callable(h) ]
if len(handlers) == 0:
raise TypeError("Unimplemented method " + what)
if len(handlers) > 1:
raise TypeError("Multiple implementations found: %s" % handlers)
handler = handlers[0]
_client_binding = ClientBinding(ps)
if docstyle:
result = handler(ps.body_root)
tc = TC.XML(aslist=1, pname=what+'Response')
elif not rpc:
try:
tc = gettypecode(typesmodule, ps.body_root)
except Exception:
tc = TC.Any()
try:
arg = tc.parse(ps.body_root, ps)
except EvaluateException as ex:
SendFault(FaultFromZSIException(ex), **kw)
return
try:
result = handler(arg)
except Exception as ex:
SendFault(FaultFromZSIException(ex), **kw)
return
try:
tc = result.typecode
except AttributeError as ex:
SendFault(FaultFromZSIException(ex), **kw)
return
elif typesmodule is not None:
kwargs = {}
for e in _child_elements(ps.body_root):
try:
tc = gettypecode(typesmodule, e)
except Exception:
tc = TC.Any()
try:
kwargs[str(e.localName)] = tc.parse(e, ps)
except EvaluateException as ex:
SendFault(FaultFromZSIException(ex), **kw)
return
result = handler(**kwargs)
aslist = False
# make sure data is wrapped, try to make this a Struct
if isinstance(result,_seqtypes):
for _ in result:
aslist = hasattr(result, 'typecode')
if aslist: break
elif not isinstance(result, dict):
aslist = not hasattr(result, 'typecode')
result = (result,)
tc = TC.Any(pname=what+'Response', aslist=aslist)
else:
# if this is an Array, call handler with list
# if this is an Struct, call handler with dict
tp = _find_type(ps.body_root)
isarray = ((isinstance(tp, (tuple,list)) and tp[1] == 'Array') or _find_arraytype(ps.body_root))
data = _child_elements(ps.body_root)
tc = TC.Any()
if isarray and len(data) == 0:
result = handler()
elif isarray:
try: arg = [ tc.parse(e, ps) for e in data ]
except EvaluateException as e:
#SendFault(FaultFromZSIException(e), **kw)
SendFault(RuntimeError("THIS IS AN ARRAY: %s" %isarray))
return
result = handler(*arg)
else:
try: kwarg = dict([ (str(e.localName),tc.parse(e, ps)) for e in data ])
except EvaluateException as e:
SendFault(FaultFromZSIException(e), **kw)
return
result = handler(**kwarg)
# reponse typecode
#tc = getattr(result, 'typecode', TC.Any(pname=what+'Response'))
tc = TC.Any(pname=what+'Response')
sw = SoapWriter(nsdict=nsdict)
sw.serialize(result, tc)
return SendResponse(str(sw), **kw)
except Fault as e:
return SendFault(e, **kw)
except Exception as e:
# Something went wrong, send a fault.
return SendFault(FaultFromException(e, 0, sys.exc_info()[2]), **kw)
def processResponse(cls, output, **kw):
sw = SoapWriter(outputclass=cls.writerClass)
sw.serialize(output)
return sw
length = int(self.headers['content-length'])
ps = ParsedSoap(self.rfile.read(length))
except ParseException, e:
ConsumerServer.logger.error(str(e))
self.send_fault(FaultFromZSIException(e))
return
except Exception, e:
ConsumerServer.logger.error(str(e))
self.send_fault(FaultFromException(e, 1, sys.exc_info()[2]))
return
try:
self.handleNotify(ps.body_root)
#TODO: missing namespace cemon_consumer
sw = SoapWriter(nsdict=NSTable)
sw.serialize(Notify(), Notify.typecode)
sw.close()
self.send_xml(str(sw))
except Exception, e:
ConsumerServer.logger.error(str(e))
import traceback
traceback.print_tb(sys.exc_info()[2])
self.send_fault(FaultFromException(e, 0, sys.exc_info()[2]))
class ConnectionFixer(object):
""" wraps a socket connection so it implements makefile """
def __init__(self, conn):
self.__conn = conn
def makefile(self, mode, bufsize):
return socket._fileobject(self.__conn, mode, bufsize)
def __getattr__(self, attrib):
protocol="SRU")
xreq.calledAt = path
result = self.call(xreq)
style = ""
except AttributeError, err:
result = self.processUnknownOperation(
operation, err, config)
reply = StringIO.StringIO()
if (req.method == "GET"):
sw = SoapWriter(reply, envelope=0)
else:
sw = SoapWriter(reply, nsdict=SRW.protocolNamespaces)
try:
sw.serialize(result, inline=1)
sw.close()
text = reply.getvalue()
except Exception, err:
self.send_fault(Fault(Fault.Client, 'Busted (%s)' % str(err)),
req)
return
if (req.method == "GET"):
if xreq and hasattr(xreq, 'stylesheet') and xreq.stylesheet:
headerText = u'<?xml version="1.0"?>\n<?xml-stylesheet type="text/xsl" href="%s"?>\n' % (
xreq.stylesheet)
elif xreq and hasattr(
xreq, 'defaultStylesheet') and xreq.defaultStylesheet:
headerText = u'<?xml version="1.0"?>\n<?xml-stylesheet type="text/xsl" href="%s"?>\n' % (
xreq.defaultStylesheet)
def Send(self,
url,
opname,
obj,
nsdict={},
soapaction=None,
wsaction=None,
endPointReference=None,
soapheaders=(),
**kw):
'''Send a message. If url is None, use the value from the
constructor (else error). obj is the object (data) to send.
Data may be described with a requesttypecode keyword, the default
is the class's typecode (if there is one), else Any.
Try to serialize as a Struct, if this is not possible serialize an Array. If
data is a sequence of built-in python data types, it will be serialized as an
Array, unless requesttypecode is specified.
arguments:
url --
opname -- struct wrapper
obj -- python instance
key word arguments:
nsdict --
soapaction --
wsaction -- WS-Address Action, goes in SOAP Header.
endPointReference -- set by calling party, must be an
EndPointReference type instance.
soapheaders -- list of pyobj, typically w/typecode attribute.
serialized in the SOAP:Header.
requesttypecode --
'''
url = url or self.url
endPointReference = endPointReference or self.endPointReference
# Serialize the object.
d = {}
d.update(self.nsdict)
d.update(nsdict)
sw = SoapWriter(
nsdict=d,
header=True,
outputclass=self.writerclass,
encodingStyle=kw.get('encodingStyle'),
)
requesttypecode = kw.get('requesttypecode')
if kw.has_key('_args'): #NamedParamBinding
tc = requesttypecode or TC.Any(pname=opname, aslist=False)
sw.serialize(kw['_args'], tc)
elif not requesttypecode:
tc = getattr(obj, 'typecode', None) or TC.Any(pname=opname,
aslist=False)
try:
if type(obj) in _seqtypes:
obj = dict(map(lambda i: (i.typecode.pname, i), obj))
except AttributeError:
# can't do anything but serialize this in a SOAP:Array
tc = TC.Any(pname=opname, aslist=True)
else:
tc = TC.Any(pname=opname, aslist=False)
sw.serialize(obj, tc)
else:
sw.serialize(obj, requesttypecode)
for i in soapheaders:
sw.serialize_header(i)
#
# Determine the SOAP auth element. SOAP:Header element
if self.auth_style & AUTH.zsibasic:
sw.serialize_header(_AuthHeader(self.auth_user, self.auth_pass),
_AuthHeader.typecode)
#
# Serialize WS-Address
if self.wsAddressURI is not None:
if self.soapaction and wsaction.strip('\'"') != self.soapaction:
raise WSActionException, 'soapAction(%s) and WS-Action(%s) must match'\
%(self.soapaction,wsaction)
self.address = Address(url, self.wsAddressURI)
self.address.setRequest(endPointReference, wsaction)
self.address.serialize(sw)
#
# WS-Security Signature Handler
if self.sig_handler is not None:
self.sig_handler.sign(sw)
scheme, netloc, path, nil, nil, nil = urlparse.urlparse(url)
transport = self.transport
if transport is None and url is not None:
if scheme == 'https':
transport = self.defaultHttpsTransport
elif scheme == 'http':
transport = self.defaultHttpTransport
else:
raise RuntimeError, 'must specify transport or url startswith https/http'
# Send the request.
if issubclass(transport, httplib.HTTPConnection) is False:
raise TypeError, 'transport must be a HTTPConnection'
soapdata = str(sw)
self.h = transport(netloc, None, **self.transdict)
self.h.connect()
self.SendSOAPData(soapdata, url, soapaction, **kw)
config=config, protocol="SRU")
xreq.calledAt = path
result = self.call(xreq)
style = ""
except AttributeError, err:
result = self.processUnknownOperation(operation, err, config)
reply = StringIO.StringIO()
if (req.method == "GET"):
sw = SoapWriter(reply, envelope=0)
else:
sw = SoapWriter(reply, nsdict=SRW.protocolNamespaces)
try:
sw.serialize(result, inline=1)
sw.close()
text = reply.getvalue()
except Exception, err:
self.send_fault(Fault(Fault.Client, 'Busted (%s)' % str(err)), req)
return
if (req.method == "GET"):
if xreq and hasattr(xreq, 'stylesheet') and xreq.stylesheet:
headerText = u'<?xml version="1.0"?>\n<?xml-stylesheet type="text/xsl" href="%s"?>\n' % (xreq.stylesheet)
elif xreq and hasattr(xreq, 'defaultStylesheet') and xreq.defaultStylesheet:
headerText = u'<?xml version="1.0"?>\n<?xml-stylesheet type="text/xsl" href="%s"?>\n' % (xreq.defaultStylesheet)
else:
headerText = u""
text = text.replace('Response>', 'Response xmlns:srw="%s" xmlns:diag="%s" xmlns:xcql="%s" xmlns:xsi="%s" xmlns:xsd="%s">' % (config.protocolNamespaces['srw'], config.protocolNamespaces['diag'], config.protocolNamespaces['xcql'], 'http://www.w3.org/2001/XMLSchema', 'http://www.w3.org/2001/XMLSchema-instance'), 1)
def Send(self, url, opname, obj, nsdict={}, soapaction=None, wsaction=None,
endPointReference=None, **kw):
'''Send a message. If url is None, use the value from the
constructor (else error). obj is the object (data) to send.
Data may be described with a requesttypecode keyword, or a
requestclass keyword; default is the class's typecode (if
there is one), else Any.
Optional WS-Address Keywords
wsaction -- WS-Address Action, goes in SOAP Header.
endPointReference -- set by calling party, must be an
EndPointReference type instance.
'''
url = url or self.url
# Get the TC for the obj.
if kw.has_key('requesttypecode'):
tc = kw['requesttypecode']
elif kw.has_key('requestclass'):
tc = kw['requestclass'].typecode
elif type(obj) == types.InstanceType:
tc = getattr(obj.__class__, 'typecode')
if tc is None: tc = TC.Any(opname, aslist=1)
else:
tc = TC.Any(opname, aslist=1)
endPointReference = endPointReference or self.endPointReference
# Serialize the object.
d = {}
d.update(self.nsdict)
d.update(nsdict)
useWSAddress = self.wsAddressURI is not None
sw = SoapWriter(nsdict=d, header=True, outputclass=self.writerclass,
encodingStyle=kw.get('encodingStyle'),)
if kw.has_key('_args'):
sw.serialize(kw['_args'], tc)
else:
sw.serialize(obj, tc)
# Determine the SOAP auth element. SOAP:Header element
if self.auth_style & AUTH.zsibasic:
sw.serialize_header(_AuthHeader(self.auth_user, self.auth_pass),
_AuthHeader.typecode)
# Serialize WS-Address
if useWSAddress is True:
if self.soapaction and wsaction.strip('\'"') != self.soapaction:
raise WSActionException, 'soapAction(%s) and WS-Action(%s) must match'\
%(self.soapaction,wsaction)
self.address = Address(url, self.wsAddressURI)
self.address.setRequest(endPointReference, wsaction)
self.address.serialize(sw)
# WS-Security Signature Handler
if self.sig_handler is not None:
self.sig_handler.sign(sw)
soapdata = str(sw)
scheme,netloc,path,nil,nil,nil = urlparse.urlparse(url)
# self.transport httplib.HTTPConnection derived class set-up removed
# from HERE - this now handled by urllib2.urlopen()
self.SendSOAPData(soapdata, url, soapaction, **kw)
