예제 #1
0
    def do_POST(self):
        '''The POST command.  This is called by HTTPServer, not twisted.
        action -- SOAPAction(HTTP header) or wsa:Action(SOAP:Header)
        '''
        global _contexts

        soapAction = self.headers.getheader('SOAPAction')
        post = self.path
        if not post:
            raise PostNotSpecified, 'HTTP POST not specified in request'
        if soapAction:
            soapAction = soapAction.strip('\'"')
        post = post.strip('\'"')
        try:
            ct = self.headers['content-type']
            if ct.startswith('multipart/'):
                cid = resolvers.MIMEResolver(ct, self.rfile)
                xml = cid.GetSOAPPart()
                ps = ParsedSoap(xml,
                                resolver=cid.Resolve,
                                readerclass=DomletteReader)
            else:
                length = int(self.headers['content-length'])
                ps = ParsedSoap(self.rfile.read(length),
                                readerclass=DomletteReader)
        except ParseException, e:
            self.send_fault(FaultFromZSIException(e))
예제 #2
0
    def test_local_attribute1(self):
        """
        """
        self.types_module

        xml = """<?xml version="1.0" encoding="UTF-8"?>
        <holder xmlns='urn:subGroup:types'>
        <baseElt><base>from base</base></baseElt>
        <childElt><base>from base</base><child>from child</child></childElt></holder>"""

        ps = ParsedSoap(xml, envelope=False)
        p1 = ps.Parse(GED("urn:subGroup:types", "holder"))

        b1 = p1.BaseElt[0]
        c1 = p1.BaseElt[1]

        sw = SoapWriter(envelope=False)
        sw.serialize(p1)

        ps = ParsedSoap(str(sw), envelope=False)
        p2 = ps.Parse(GED("urn:subGroup:types", "holder"))
        b2 = p2.BaseElt[0]
        c2 = p2.BaseElt[1]

        self.assertEqual(b1.Base, b2.Base)
        self.assertEqual(c1.Base, c2.Base)
        self.assertEqual(c1.Child, c2.Child)
예제 #3
0
    def do_POST(self):
        '''The POST command.  This is called by HTTPServer, not twisted.
        action -- SOAPAction(HTTP header) or wsa:Action(SOAP:Header)
        '''
        global _contexts

        soapAction = self.headers.getheader('SOAPAction')
        post = self.path
        if not post:
            raise PostNotSpecified('HTTP POST not specified in request')
        if soapAction:
            soapAction = soapAction.strip('\'"')
        post = post.strip('\'"')
        try:
            ct = self.headers['content-type']
            if ct.startswith('multipart/'):
                cid = resolvers.MIMEResolver(ct, self.rfile)
                xml = cid.GetSOAPPart()
                ps = ParsedSoap(xml,
                                resolver=cid.Resolve,
                                readerclass=DomletteReader)
            else:
                length = int(self.headers['content-length'])
                ps = ParsedSoap(self.rfile.read(length),
                                readerclass=DomletteReader)
        except ParseException as e:
            self.send_fault(FaultFromZSIException(e))
        except Exception as e:
            # Faulted while processing; assume it's in the header.
            self.send_fault(FaultFromException(e, 1, sys.exc_info()[2]))
        else:
            # Keep track of calls
            thread_id = _thread.get_ident()
            _contexts[thread_id] = SOAPContext(self.server, xml, ps,
                                               self.connection, self.headers,
                                               soapAction)

            try:
                _Dispatch(ps,
                          self.server,
                          self.send_xml,
                          self.send_fault,
                          post=post,
                          action=soapAction)
            except Exception as e:
                self.send_fault(FaultFromException(e, 0, sys.exc_info()[2]))

            # Clean up after the call
            if thread_id in _contexts:
                del _contexts[thread_id]
예제 #4
0
    def check_list_defs(self):
        gl = globals()
        for klass in map(
                lambda h: gl[h],
                filter(
                    lambda g: (g.startswith('TestList') and issubclass(
                        gl[g], ZSI.TC.List)), gl)):

            typecode = klass('whatever', nillable=True)
            data = None
            for i in range(10):
                sw = SoapWriter()
                sw.serialize(data, typecode)
                s = str(sw)
                print s
                ps = ParsedSoap(s)
                pyobj = ps.Parse(typecode)
                assert pyobj == data, 'Data corruption expected "%s", got "%s"' % (
                    str(data), str(pyobj))
                if data is None:
                    data = []
                    continue

                #
                # cut last 3 fields off: weekday (0-6, Monday is 0), Julian day (day in the year, 1-366),
                # DST (Daylight Savings Time) flag (-1, 0 or 1)
                #
                utc = list(time.gmtime(i)[:-3]) + [999, 0, 0]
                data.append(tuple(utc))
예제 #5
0
    def test_local_type_substitution1(self):
        """test extension.   Parse known instance, serialize an equivalent, Parse it back. """
        attr1 = 'myclass'
        attr2 = 'whatever'
        self.types_module
        pyobj = GED('urn:test', 'test').pyclass()

        # [ 1489129 ] Unexpected subsitution error message
        #  try to parse before type ever initialized
        ps = ParsedSoap(MSG1)
        pyobj0 = ps.Parse(pyobj.typecode)
        sub0 = pyobj0.Actor
        self.failUnless(sub0.get_attribute_attr1() == attr1, 'bad attribute1')
        self.failUnless(sub0.get_attribute_attr2() == attr2, 'bad attribute2')

        # [ 1489090 ] Derived type attributes don't populate the attr dictionary
        #
        pyobj.Actor = sub1 = GTD('urn:test', 'MiddleActor')(None).pyclass()
        sub1.Element1 = 'foo'
        sub1.Element2 = 'bar'
        sub1.set_attribute_attr1(attr1)
        sub1.set_attribute_attr2(attr2)

        sw = SoapWriter()
        sw.serialize(pyobj)
        xml = str(sw)
        ps = ParsedSoap(xml)
        pyobj2 = ps.Parse(pyobj.typecode)
        sub2 = pyobj2.Actor

        self.failUnless(sub2.get_attribute_attr1() == attr1,
                        'bad attribute class')
        self.failUnless(sub2.get_attribute_attr2() == attr2,
                        'bad attribute name')

        # check parsed out correct type
        self.failUnless(
            isinstance(sub2.typecode, sub1.typecode.__class__),
            'local element actor "%s" must be an instance of "%s"' %
            (sub2.typecode, sub1.typecode.__class__))

        # check local element is derived from base
        base = GTD('urn:test', 'BaseActor')
        self.failUnless(
            isinstance(sub2.typecode, base),
            'local element actor must be a derived type of "%s"' % base)
 def _Deserialize(self, xml):
     # Doc/lit
     ps = ParsedSoap(xml, readerClass=None, keepdom=False)
     return ZSI.TC.AnyElement(aname="any",
                              minOccurs=0,
                              maxOccurs=1,
                              nillable=False,
                              processContents="lax").parse(
                                  ps.body_root, ps)
예제 #7
0
    def test_local_parse_missing_type_substitution(self):
        """attempt to substitute an unregistered/unknown type """
        attr1 = 'myclass'
        attr2 = 'whatever'
        self.types_module
        pyobj = GED('urn:test', 'test').pyclass()

        ps = ParsedSoap(NO_SUB_MSG)
        self.failUnlessRaises(EvaluateException, ps.Parse, pyobj.typecode)
예제 #8
0
    def test_local_type_substitution2(self):
        """test extension of extension"""

        attr1 = 'aone'
        attr2 = 'atwo'
        attr3 = 'athree'
        self.types_module
        pyobj = GED('urn:test', 'test').pyclass()

        # [ 1489129 ] Unexpected subsitution error message
        #  try to parse before type ever initialized
        """
        ps = ParsedSoap(MSG1)
        pyobj0 = ps.Parse(pyobj.typecode)
        sub0 = pyobj0.Actor
        self.failUnless(sub0.get_attribute_attr1() == attr1, 'bad attribute1')
        self.failUnless(sub0.get_attribute_attr2() == attr2, 'bad attribute2')
        """

        # [ 1489090 ] Derived type attributes don't populate the attr dictionary
        # [ 1489677 ] Derivation from derived type missing derived element
        #
        pyobj.Actor = sub1 = GTD('urn:test', 'TopActor')(None).pyclass()
        sub1.Element1 = 'one'
        sub1.Element2 = 'two'
        sub1.Element3 = 'three'
        sub1.set_attribute_attr1(attr1)
        sub1.set_attribute_attr2(attr2)
        sub1.set_attribute_attr3(attr3)

        sw = SoapWriter()
        sw.serialize(pyobj)
        xml = str(sw)
        ps = ParsedSoap(xml)
        pyobj2 = ps.Parse(pyobj.typecode)
        sub2 = pyobj2.Actor

        self.failUnless(sub2.get_attribute_attr1() == attr1, 'bad attribute 1')
        self.failUnless(sub2.get_attribute_attr2() == attr2, 'bad attribute 2')
        self.failUnless(sub2.get_attribute_attr3() == attr3, 'bad attribute 3')

        self.failUnless(sub2.Element1 == sub1.Element1, 'bad element 1')
        self.failUnless(sub2.Element2 == sub1.Element2, 'bad element 2')
        self.failUnless(sub2.Element3 == sub1.Element3, 'bad element 3')

        # check parsed out correct type
        self.failUnless(
            isinstance(sub2.typecode, sub1.typecode.__class__),
            'local element actor "%s" must be an instance of "%s"' %
            (sub2.typecode, sub1.typecode.__class__))

        # check local element is derived from base
        base = GTD('urn:test', 'BaseActor')
        self.failUnless(
            isinstance(sub2.typecode, base),
            'local element actor must be a derived type of "%s"' % base)
예제 #9
0
    def do_POST(self):
        '''The POST command.
        action -- SOAPAction(HTTP header) or wsa:Action(SOAP:Header)
        '''
        self._fix_chunked_encoding()

        logger.debug("Request Host: {}".format(self.client_address))
        logger.debug("Request URI: {}".format(self.requestline))
        for key, value in self.headers.items():
            logger.debug("Request Header: {}: {}".format(key, value))
        content_type = self.headers.get("content-type", '')
        action_matchobj = re.search("action=\"(urn:\w+)\"", content_type)
        if action_matchobj is not None:
            # SOAP 1.2
            soapAction = action_matchobj.group(1)
        else:
            # SOAP 1.1
            soapAction = self.headers.getheader('SOAPAction')
            if soapAction:
                soapAction = soapAction.strip('\'"')
        self._soapAction = soapAction
        post = self.path
        if not post:
            raise PostNotSpecified, 'HTTP POST not specified in request'
        post = post.strip('\'"')
        try:
            ct = self.headers['content-type']
            if ct.startswith('multipart/'):
                cid = resolvers.MIMEResolver(ct, self.rfile)
                xml = cid.GetSOAPPart()
                ps = ParsedSoap(xml, resolver=cid.Resolve)
            else:
                length = int(self.headers['content-length'])
                xml = self.rfile.read(length)
                logger.debug("Request Body: {}".format(xml))
                ps = ParsedSoap(xml)
        except ParseException, e:
            self.send_fault(FaultFromZSIException(e))
예제 #10
0
    def check_union_long(self):
        import time
        typecode = GED("http://www.pasoa.org/schemas/version024/PStruct.xsd", "localPAssertionId")
        for value in (1234455, "whatever", "urn:whatever"):
            sw = ZSI.SoapWriter()
            sw.serialize(value, typecode)

            xml = str(sw)
            ps = ParsedSoap(xml)
            pyobj = ps.Parse(typecode)

            # Union Limitation:  
            #     currently it tries to parse it sequentially via memberTypes,
            #     so string is going to parse the URI when we want anyURI
            self.failUnless(value == pyobj, 'Expected equivalent')
예제 #11
0
    def test_local_empty_attribute(self):
        # [ 1452752 ] attribute with empty value doesn't appear in parsed object
        myString = ""
        pyobj = GED("urn:example", "Test1").pyclass()
        pyobj.set_attribute_myString(myString)

        sw = SoapWriter()
        sw.serialize(pyobj)
        soap = str(sw)

        print soap
        ps = ParsedSoap(soap)
        pyobj2 = ps.Parse(pyobj.typecode)

        test = pyobj2.get_attribute_myString()
        self.failUnlessEqual(myString, str(test))
예제 #12
0
파일: test_t9.py 프로젝트: 0z-cloud/ZSI-Py3
    def check_c14n_exc3(self):
        """http://www.w3.org/TR/xml-exc-c14n/
        tests if a namespace defined in a parent node to the top node 
        to be canonicalized is added when discovered that this namespace
        is used.
        """
        self.ps = ParsedSoap(XML_INST2)
        self.el = self.ps.body

        s = StringIO()
        Canonicalize(self.el, s, unsuppressedPrefixes=[])
        cxml = s.getvalue()
        print(cxml)
        d1 = base64.encodestring(sha.sha(C14N_EXCL3).digest()).strip()
        d2 = base64.encodestring(sha.sha(cxml).digest()).strip()
        self.assertEqual(d1, C14N_EXCL3_DIGEST)
        self.assertEqual(d1, d2)
예제 #13
0
    def test_local_type_substitution_test2(self):
        """test extension of extension"""

        attr1 = 'aone'
        attr2 = 'atwo'
        attr3 = 'athree'
        self.types_module
        pyobj = GED('urn:test', 'test2').pyclass()

        # Test maxOccurs>1 for substitution
        #
        pyobj.Actor = [GTD('urn:test', 'TopActor')(None).pyclass()]
        sub1 = pyobj.Actor[0]
        sub1.Element1 = 'one'
        sub1.Element2 = 'two'
        sub1.Element3 = 'three'
        sub1.set_attribute_attr1(attr1)
        sub1.set_attribute_attr2(attr2)
        sub1.set_attribute_attr3(attr3)

        sw = SoapWriter()
        sw.serialize(pyobj)
        xml = str(sw)
        ps = ParsedSoap(xml)
        pyobj2 = ps.Parse(pyobj.typecode)
        sub2 = pyobj2.Actor[0]

        self.failUnless(sub2.get_attribute_attr1() == attr1, 'bad attribute 1')
        self.failUnless(sub2.get_attribute_attr2() == attr2, 'bad attribute 2')
        self.failUnless(sub2.get_attribute_attr3() == attr3, 'bad attribute 3')

        self.failUnless(sub2.Element1 == sub1.Element1, 'bad element 1')
        self.failUnless(sub2.Element2 == sub1.Element2, 'bad element 2')
        self.failUnless(sub2.Element3 == sub1.Element3, 'bad element 3')

        # check parsed out correct type
        self.failUnless(
            isinstance(sub2.typecode, sub1.typecode.__class__),
            'local element actor "%s" must be an instance of "%s"' %
            (sub2.typecode, sub1.typecode.__class__))

        # check local element is derived from base
        base = GTD('urn:test', 'BaseActor')
        self.failUnless(
            isinstance(sub2.typecode, base),
            'local element actor must be a derived type of "%s"' % base)
예제 #14
0
    def processResponse(cls, soapdata, **kw):
        """called by deferred, returns pyobj representing reply.
        Parameters and Key Words:
          soapdata -- SOAP Data
          replytype -- reply type of response
        """
        if len(soapdata) == 0:
            raise TypeError('Received empty response')


#        log.msg("_" * 33, time.ctime(time.time()),
#                  "RESPONSE: \n%s" %soapdata, debug=True)

        ps = ParsedSoap(soapdata, readerclass=cls.readerClass)
        if ps.IsAFault() is True:
            log.msg('Received SOAP:Fault', debug=True)
            raise FaultFromFaultMessage(ps)

        return ps
예제 #15
0
    def xcheck_c14n_exc4(self):
        RCVDIGEST = "jhTbi7gWlY9oLqsRr+EZ0bokRFA="
        CALDIGEST = "IkMyI4zCDlK41qE7sZxvkFHJioU="

        d1 = base64.encodestring(sha.sha(WRONG).digest()).strip()
        d2 = base64.encodestring(sha.sha(CORRECT).digest()).strip()

        ps = ParsedSoap(XML_INST4)
        el = filter(lambda el: _get_element_nsuri_name(el) == (WSA200403.ADDRESS, "MessageID"), 
                      ps.header_elements)[0]

        s = StringIO()
        Canonicalize(el, s, unsuppressedPrefixes=[])
        cxml = s.getvalue()
        print "-- "*20
        print cxml
        print "-- "*20
        d3 = base64.encodestring(sha.sha(cxml).digest()).strip()

        self.assertEqual(d1, RCVDIGEST)
        self.assertEqual(d2, CALDIGEST)
        self.assertEqual(d3, CALDIGEST)
예제 #16
0
    def test_local_attribute1(self):
        """
        """
        myDouble = 4.5
        myInt = 9
        myFloat = 3.0001
        myDecimal = 8.999
        myGDateTime = time.gmtime()
        myAnyURI = "urn:whatever"
        myQName = ("urn:test", "qbert")
        myString = "whatever"
        myHexBinary = hex(888)

        pyobj = GED("urn:example", "Test1").pyclass()
        # Test serialize/parse
        pyobj.set_attribute_myDecimal(myDecimal)
        pyobj.set_attribute_myDouble(myDouble)
        pyobj.set_attribute_myFloat(myFloat)
        pyobj.set_attribute_myInt(myInt)
        pyobj.set_attribute_myDateTime(myGDateTime)

        pyobj.set_attribute_myGDay(myGDateTime)
        pyobj.set_attribute_myGMonth(myGDateTime)
        pyobj.set_attribute_myGYear(myGDateTime)
        pyobj.set_attribute_myGYearMonth(myGDateTime)
        pyobj.set_attribute_myDate(myGDateTime)
        pyobj.set_attribute_myTime(myGDateTime)

        pyobj.set_attribute_myAnyURI(myAnyURI)
        pyobj.set_attribute_myString(myString)
        pyobj.set_attribute_myHexBinary(myHexBinary)
        pyobj.set_attribute_myDuration(myGDateTime)

        # Problems parsings
        pyobj.set_attribute_myQName(myQName)
        pyobj.set_attribute_myGMonthDay(myGDateTime)

        #TODO:
        #pyobj.set_attribute_myBase64Binary("")
        #pyobj.set_attribute_myNOTATION("NOT")

        sw = SoapWriter()
        sw.serialize(pyobj)
        soap = str(sw)

        ps = ParsedSoap(soap)
        pyobj2 = ps.Parse(pyobj.typecode)

        test = pyobj2.get_attribute_myInt()
        self.failUnlessEqual(myInt, test)

        test = pyobj2.get_attribute_myDouble()
        self.failUnlessEqual(myDouble, test)

        test = pyobj2.get_attribute_myFloat()
        self.failUnlessEqual(myFloat, test)

        test = pyobj2.get_attribute_myDecimal()
        self.failUnlessEqual(myDecimal, test)

        test = pyobj2.get_attribute_myAnyURI()
        self.failUnlessEqual(myAnyURI, test)

        test = pyobj2.get_attribute_myQName()
        self.failUnlessEqual(myQName, test)

        test = pyobj2.get_attribute_myString()
        self.failUnlessEqual(myString, test)

        test = pyobj2.get_attribute_myHexBinary()
        self.failUnlessEqual(myHexBinary, test)

        # DateTime stuff
        test = pyobj2.get_attribute_myDateTime()
        self.failUnlessEqual(myGDateTime[:-3], test[:-3])

        test = pyobj2.get_attribute_myDate()
        self.failUnlessEqual(myGDateTime[:3], test[:3])

        test = pyobj2.get_attribute_myTime()
        self.failUnlessEqual(myGDateTime[4:5], test[4:5])

        test = pyobj.get_attribute_myDuration()
        self.failUnlessEqual(myGDateTime, test)

        # Bug [ 1453421 ] Incorrect format for type gDay
        test = pyobj2.get_attribute_myGDay()
        self.failUnlessEqual(myGDateTime[2], test[2])

        test = pyobj2.get_attribute_myGMonth()
        self.failUnlessEqual(myGDateTime[1], test[1])

        test = pyobj2.get_attribute_myGYear()
        self.failUnlessEqual(myGDateTime[0], test[0])

        test = pyobj2.get_attribute_myGYearMonth()
        self.failUnlessEqual(myGDateTime[:2], test[:2])
예제 #17
0
파일: test_t9.py 프로젝트: 0z-cloud/ZSI-Py3
 def setUp(self):
     self.ps = ParsedSoap(XML_INST1)
     self.el = [
         el for el in self.ps.header_elements
         if _get_element_nsuri_name(el) == (WSA200403.ADDRESS, "From")
     ][0]
예제 #18
0
파일: test_t9.py 프로젝트: acigna/pywez
 def setUp(self):
     self.ps = ParsedSoap(XML_INST1)
     self.el = filter(
         lambda el: _get_element_nsuri_name(el) ==
         (WSA200403.ADDRESS, "From"), self.ps.header_elements)[0]
예제 #19
0
 def processRequest(cls, input, **kw):
     return ParsedSoap(input, readerclass=cls.readerClass)