def __init__(self, url, **kwargs):
"""
@param url: The URL for the WSDL.
@type url: str
@param kwargs: keyword arguments.
@see: L{Options}
"""
options = Options()
options.transport = HttpAuthenticated()
self.options = options
if "cache" not in kwargs:
kwargs["cache"] = ObjectCache(days=1)
self.set_options(**kwargs)
reader = DefinitionsReader(options, Definitions)
self.wsdl = reader.open(url)
plugins = PluginContainer(options.plugins)
plugins.init.initialized(wsdl=self.wsdl)
self.factory = Factory(self.wsdl)
self.service = ServiceSelector(self, self.wsdl.services)
self.sd = []
for s in self.wsdl.services:
sd = ServiceDefinition(self.wsdl, s)
self.sd.append(sd)
self.messages = dict(tx=None, rx=None)
def setUp(self):
import os
os.environ['PYTHONHASHSEED'] = '100'
options = Options()
self.r = Reader(options)
def __init__(self, cert, key, options=Options()):
HttpTransport.__init__(self, options)
self.handler = HTTPSClientAuthHandler(cert, key)
self.urlopener = urllib2.build_opener(self.handler)
def buildOptions(self):
options = Options()
options.wsse.enabled = self.wsseEnabled
if self.wsseEnabled:
options.wsse.includeTimestamp = self.includeTimestamp
options.wsse.encryptThenSign = self.encryptThenSign
options.wsse.signOnlyEntireHeadersAndBody = self.onlySignEntireHeadersAndBody
if self.wsse11 is not None:
options.wsse.wsse11 = self.wsse11
if self.headerLayout is not None:
options.wsse.headerLayout = self.headerLayout
def create_signed_header_ns_func(ns):
return lambda env, sig: filter(
lambda header: header.namespace()[1] == ns,
env.getChild("Header").getChildren())
def create_signed_header_func(ns, name):
return lambda env, sig: env.getChild("Header").getChildren(
name, ns=(None, ns))
def create_encrypted_header_ns_func(ns, name):
return lambda env: [(hdr, 'Element') for hdr in filter(
lambda header: header.namespace()[1] == ns,
env.getChild("Header").getChildren())]
def create_encrypted_header_func(ns, name):
return lambda env: (env.getChild("Header").getChildren(
name, ns=(None, ns)), 'Element')
def create_signed_username_token_func(index):
return lambda env, sig: env.getChild("Header").getChild(
"Security").getChildren("UsernameToken")[index]
def create_signed_binary_token_func(index):
return lambda env, sig: env.getChild("Header").getChild(
"Security").getChildren("BinarySecurityToken")[index]
def create_encrypted_username_token_func(index):
return lambda env: (env.getChild("Header").getChild(
"Security").getChildren("UsernameToken")[index], 'Element')
def create_encrypted_binary_token_func(index):
return lambda env: (env.getChild("Header").getChild(
"Security").getChildren("BinarySecurityToken")[index],
'Element')
index = 0
for sig in self.signatures:
if self.digestAlgorithm is not None:
options.wsse.signatures[
index].digest = self.digestAlgorithm
if sig.keyReference is not None:
options.wsse.signatures[
index].keyreference = sig.keyReference
if sig.signatureAlgorithm is not None:
options.wsse.signatures[
index].signaturealgorithm = sig.signatureAlgorithm
signed_parts = []
for part in sig.signedParts:
if part[0] == 'body':
signed_parts.append(
lambda env, sig: env.getChild("Body"))
elif part[0] == 'header':
if part[2] is None:
signed_parts.append(
create_signed_header_ns_func(part[1]))
else:
signed_parts.append(
create_signed_header_func(part[1], part[2]))
elif part[0] == 'timestamp':
signed_parts.append(lambda env, sig: env.childAtPath(
"Header/Security/Timestamp"))
elif part[0] == 'primary_signature':
signed_parts.append(lambda env, sig: sig.primary_sig)
elif part[0] == 'token':
if part[1] == 'self':
signed_parts.append(lambda env, sig: sig.token)
elif part[1] == 'token':
signed_parts.append(
create_signed_username_token_func(part[2]))
elif part[1] == 'signature':
signed_parts.append(
create_signed_binary_token_func(part[2]))
options.wsse.signatures[index].signedparts = signed_parts
index = index + 1
index = 0
for key in self.keys:
if self.blockEncryption is not None:
options.wsse.keys[
index].blockencryption = self.blockEncryption
if self.keyTransport is not None:
options.wsse.keys[index].keytransport = self.keyTransport
if key.keyReference is not None:
options.wsse.keys[index].keyreference = key.keyReference
options.wsse.keys[index].includereflist = key.includeRefList
encrypted_parts = []
for part in key.encryptedParts:
if part[0] == 'body':
encrypted_parts.append(
lambda env: (env.getChild("Body"), "Content"))
elif part[0] == 'header':
if part[2] is None:
encrypted_parts.append(
create_encrypted_header_ns_func(part[1]))
else:
encrypted_parts.append(
create_encrypted_header_func(part[1], part[2]))
elif part[0] == 'signature':
encrypted_parts.append(
lambda env: (env.getChild('Header').getChild(
'Security').getChild('Signature'), 'Element'))
elif part[0] == 'token':
if part[1] == 'token':
encrypted_parts.append(
create_encrypted_username_token_func(part[2]))
elif part[1] == 'signature':
encrypted_parts.append(
create_encrypted_binary_token_func(part[2]))
options.wsse.keys[index].encryptedparts = encrypted_parts
second_pass_encrypted_parts = []
for part in key.secondPassEncryptedParts:
if part[0] == 'body':
second_pass_encrypted_parts.append(
lambda env: (env.getChild("Body"), "Content"))
elif part[0] == 'header':
second_pass_encrypted_parts.append(
create_encrypted_header_func(part[1], part[2]))
elif part[0] == 'signature':
second_pass_encrypted_parts.append(
lambda env: (env.getChild('Header').getChild(
'Security').getChild('Signature'), 'Element'))
options.wsse.keys[
index].secondpassencryptedparts = second_pass_encrypted_parts
index = index + 1
if self.addressing is not None:
options.wsaddr = self.addressing
if self.clientCertRequired:
options.transport.protocol = PROTOCOL_HTTPS_CERT_AUTH
return options
def __init__(self, key, cert, options = Options()):
HttpTransport.__init__(self)
self.urlopener = urllib2.build_opener(HTTPSClientAuthHandler(key, cert))
def mangle(url, typ):
return Reader(Options()).mangle(url, typ)
def test_getf_mangled(self):
mangled = Reader(Options()).mangle(self.url, 'document')
self.getf(mangled)
def clear_suds_cache(wsdl):
for type in ("wsdl", "document"):
cacheId = Reader(Options()).mangle(wsdl, type)
DocumentCache().purge(cacheId)
ObjectCache().purge(cacheId)
FileCache().purge(cacheId)
