Ejemplo n.º 1
0
    def AsSOAP(self, **kw):

        header = self.DataForSOAPHeader()
        sw = SoapWriter(**kw)
        self.serialize(sw)
        if header is not None:
            sw.serialize_header(header, header.typecode, typed=False)
        return str(sw)
Ejemplo n.º 2
0
    def AsSOAP(self, **kw):

        header = self.DataForSOAPHeader() 
        sw = SoapWriter(**kw)
        self.serialize(sw)
        if header is not None:
            sw.serialize_header(header, header.typecode, typed=False)
        return str(sw)
Ejemplo n.º 3
0
	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)
Ejemplo n.º 4
0
    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 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)