Python io.Reactor类代码示例

    def testPostMethodDeCompressesDeflatedBody_gzip(self):
        self.requestData = None
        def handler(**kwargs):
            self.requestData = kwargs

        reactor = Reactor()
        server = HttpServer(reactor, self.port, handler, timeout=0.01)
        server.listen()
        sok = socket()
        sok.connect(('localhost', self.port))
        bodyData = 'bodydatabodydata'
        _sio = StringIO()
        _gzFileObj = GzipFile(filename=None, mode='wb', compresslevel=6, fileobj=_sio)
        _gzFileObj.write(bodyData); _gzFileObj.close()
        compressedBodyData = _sio.getvalue()
        bodyDataCompressed = compress(bodyData)
        contentLengthCompressed = len(bodyDataCompressed)
        sok.send(('POST / HTTP/1.0\r\nContent-Type: application/x-www-form-urlencoded\r\nContent-Length: %d\r\nContent-Encoding: gzip\r\n\r\n' % contentLengthCompressed) + bodyDataCompressed)

        while not self.requestData:
            reactor.step()
        self.assertEquals(dict, type(self.requestData))
        self.assertTrue('Headers' in self.requestData)
        headers = self.requestData['Headers']
        self.assertEquals('POST', self.requestData['Method'])
        self.assertEquals('application/x-www-form-urlencoded', headers['Content-Type'])
        self.assertEquals(contentLengthCompressed, int(headers['Content-Length']))

        self.assertTrue('Body' in self.requestData)
        self.assertEquals('bodydatabodydata', self.requestData['Body'])

 def testInvalidTime(self):
     reactor = Reactor()
     try:
         reactor.addTimer(-1, None)
         self.fail('should raise exeption')
     except Exception, e:
         self.assertEquals('Timeout must be >= 0. It was -1.', str(e))

 def testGlobalReactor(self):
     from weightless.io import reactor
     thereactor = Reactor()
     def handler():
         self.assertEquals(thereactor, reactor())
     thereactor.addTimer(0, handler)
     thereactor.step()

    def testPostMethodDeCompressesDeflatedBody_deflate(self):
        self.requestData = None
        def handler(**kwargs):
            self.requestData = kwargs

        reactor = Reactor()
        server = HttpServer(reactor, self.port, handler, timeout=0.01)
        server.listen()
        sok = socket()
        sok.connect(('localhost', self.port))
        bodyData = 'bodydatabodydata'
        bodyDataCompressed = compress(bodyData)
        contentLengthCompressed = len(bodyDataCompressed)
        sok.send(('POST / HTTP/1.0\r\nContent-Type: application/x-www-form-urlencoded\r\nContent-Length: %d\r\nContent-Encoding: deflate\r\n\r\n' % contentLengthCompressed) + bodyDataCompressed)

        while not self.requestData:
            reactor.step()
        self.assertEquals(dict, type(self.requestData))
        self.assertTrue('Headers' in self.requestData)
        headers = self.requestData['Headers']
        self.assertEquals('POST', self.requestData['Method'])
        self.assertEquals('application/x-www-form-urlencoded', headers['Content-Type'])
        self.assertEquals(contentLengthCompressed, int(headers['Content-Length']))  # TS: is this correct?, maybe decompressed length?

        self.assertTrue('Body' in self.requestData)
        self.assertEquals('bodydatabodydata', self.requestData['Body'])

 def testInvalidPOSTRequestStartsOnlyOneTimer(self):
     # problem in found in OAS, timers not removed properly when whole body hasnt been read yet
     _httpserver.RECVSIZE = 1
     reactor = Reactor()
     timers = []
     orgAddTimer = reactor.addTimer
     def addTimerInterceptor(*timer):
         timers.append(timer)
         return orgAddTimer(*timer)
     reactor.addTimer = addTimerInterceptor
     server = HttpServer(reactor, self.port, lambda **kwargs: (x for x in []), timeout=0.01)
     server.listen()
     sok = socket()
     sok.connect(('localhost', self.port))
     sok.send('POST / HTTP/1.0\r\nContent-Length: 10\r\n\r\n')
     reactor.step()
     sok.send(".")
     sleep(0.1)
     reactor.step()
     sok.send(".")
     reactor.step()
     sleep(0.1)
     while select([sok],[], [], 0) != ([sok], [], []):
         reactor.step()
     self.assertEquals(2, len(timers))

    def testPost(self):
        port = randint(2048, 4096)
        reactor = Reactor()
        request = "POST / HTTP/1.1\r\nHost: localhost\r\nTransfer-Encoding: chunked\r\nSOAPAction: blah\r\nUser-Agent: Weightless/v%s\r\n\r\n1\r\nA\r\n1\r\nB\r\n1\r\nC\r\n0\r\n\r\n" % WlVersion
        serverThread = server(port, "HTTP/1.1 200 OK\r\n\r\nresponse", request, loop=9)
        sentData = []
        done = []
        def send(data):
            sentData.append(data)
        def throw(exception):
            if isinstance(exception, StopIteration):
                done.append(True)
        def next():
            yield "A"
            yield "B"
            yield "C"
            yield None

        reader = HttpReaderFacade(reactor, "http://localhost:%s" % port, send, errorHandler=throw, timeout=0.5, headers={'SOAPAction': 'blah'}, bodyHandler=next)

        reactor.addTimer(3.0, lambda: self.fail("Test Stuck"))
        while not done:
            reactor.step()

        self.assertEquals(['response'], sentData[1:])
        self.assertEquals('200', sentData[0]['StatusCode'])
        expected = 'POST / HTTP/1.1\r\nHost: localhost\r\nTransfer-Encoding: chunked\r\nSOAPAction: blah\r\nUser-Agent: Weightless/v%s\r\n\r\n' % WlVersion + '1\r\nA\r\n' + '1\r\nB\r\n' + '1\r\nC\r\n' + '0\r\n\r\n'
        self.assertEquals(expected, "".join(request))

    def testDealWithChunkedResponse(self):
        port = randint(2048, 4096)
        reactor = Reactor()
        sentData = []
        done = []
        expectedrequest = "GET / HTTP/1.1\r\nHost: localhost\r\nUser-Agent: Weightless/v%s\r\n\r\n" % WlVersion
        serverThread = server(port, "\r\n".join("""HTTP/1.1 302 Found
Date: Fri, 26 Oct 2007 07:23:26 GMT
Server: Apache/2.2.3 (Debian) mod_python/3.2.10 Python/2.4.4 mod_ssl/2.2.3 OpenSSL/0.9.8c
Location: /page/softwarestudio.page/show
Transfer-Encoding: chunked
Content-Type: text/html; charset=utf-8

4F
<p>The document has moved <a href="/page/softwarestudio.page/show">here</a></p>

0


""".split("\n")), expectedrequest)
        class Handler:
            def send(self, data):
                sentData.append(data)
            def throw(self, exception):
                if isinstance(exception, StopIteration):
                    done.append(True)
        reader = HttpReader(reactor, Connector(reactor, 'localhost', int(port)), Handler(), 'GET', 'localhost', '/', recvSize=5)

        reactor.addTimer(0.2, lambda: self.fail("Test Stuck"))
        while not done:
            reactor.step()
        self.assertEquals("""<p>The document has moved <a href="/page/softwarestudio.page/show">here</a></p>""", "".join(sentData[1:]))

def startServer(port, stateDir, luceneserverPort, gatewayPort, quickCommit=False, **ignored):
    
    setSignalHandlers()
    print 'Firing up Index Server.'

    statePath = abspath(stateDir)
    writerReactor = Reactor()

    writer = writerMain(
            writerReactor=writerReactor,
            statePath=statePath,
            luceneserverPort=luceneserverPort,
            gatewayPort=gatewayPort,
            quickCommit=quickCommit,
        )

    writerServer = be(writer)

    # Start writer in main (this) thread:
    consume(writerServer.once.observer_init())

    registerShutdownHandler(statePath=statePath, server=writerServer, reactor=writerReactor, shutdownMustSucceed=False)


    print "Ready to rumble at port %s" % port
    stdout.flush()

    writerReactor.loop()
    

 def testRemoveTimer(self):
     def itsTime(): pass
     reactor = Reactor()
     token1 = reactor.addTimer(0.05, itsTime)
     token2 = reactor.addTimer(0.051, itsTime)
     reactor.removeTimer(token1)
     self.assertEquals(1, len(reactor._timers))

def startServer(**kwargs):
    reactor = Reactor()

    server = be(dna(reactor=reactor, **kwargs))
    list(compose(server.once.observer_init()))

    print "Ready to rumble at", kwargs['port']
    reactor.loop()

 def testTimerDoesNotMaskAssertionErrors(self):
     reactor = Reactor()
     reactor.addTimer(0, lambda: self.fail("Assertion Error"))
     try:
         reactor.step()
         raise Exception('step() must raise AssertionError')
     except AssertionError:
         self.assertEquals([], reactor._timers)

 def testDoNotMaskOtherErrors(self):
     def raiser(*args): raise Exception('oops')
     reactor = Reactor(raiser)
     try:
         reactor.step()
         self.fail('must raise oops')
     except Exception, e:
         self.assertEquals('oops', str(e))

 def testAddSocketRaisesException(self):
     class Sok: # raise exception when put into set
         def __hash__(self): raise Exception('aap')
     reactor = Reactor()
     try:
         reactor.addReader(Sok(), None)
         self.fail()
     except Exception, e:
         self.assertEquals('aap', str(e))

 def testEmptyPath(self):
     port = randint(2**10, 2**16)
     reactor = Reactor()
     request = "GET / HTTP/1.1\r\nHost: localhost\r\nUser-Agent: Weightless/v%s\r\n\r\n" % WlVersion
     serverThread = server(port, "HTTP/1.1 200 OK\r\n\r\n", request)
     reader = HttpReaderFacade(reactor, "http://localhost:%s" % port, lambda data: 'a')
     reactor.step()
     reactor.step()
     serverThread.join()

class AsyncReaderTest(WeightlessTestCase):

    def dispatch(self, *args, **kwargs):
        return compose(self.handler(*args, **kwargs))

    def setUp(self):
        WeightlessTestCase.setUp(self)
        self.reactor = Reactor()
        self.port = randint(2**10, 2**16)
        self.httpserver = HttpServer(self.reactor, self.port, self.dispatch)
        self.httpserver.listen()

    def tearDown(self):
        self.httpserver.shutdown()
        self.reactor.shutdown()
        WeightlessTestCase.tearDown(self)

    def testHttpRequest(self):
        self.assertEquals('GET / HTTP/1.0\r\n', _httpRequest('GET', '/'))
        self.assertEquals('POST / HTTP/1.0\r\n', _httpRequest('POST', '/'))

    def testPassRequestThruToBackOfficeServer(self):
        done = [False]
        backofficeport = self.port + 1
        def passthruhandler(*args, **kwargs):
            request = kwargs['RequestURI']
            response = yield httpget('localhost', backofficeport, request)
            yield response
            done[0] = True
        self.handler = passthruhandler
        expectedrequest = "GET /depot?arg=1&arg=2 HTTP/1.0\r\n\r\n"
        responses = (i for i in ['hel', 'lo!'])
        backofficeserver = testserver(backofficeport, responses, expectedrequest)
        client = clientget('localhost', self.port, '/depot?arg=1&arg=2')
        while not done[0]:
            self.reactor.step()
        response = client.recv(99)
        self.assertEquals('hello!', response)

    def testConnectFails(self):
        exceptions = []
        def failingserver(*args, **kwarg):
            try:
                response = yield httpget(*target)
            except Exception, e:
                exceptions.append(exc_info())
        self.handler = failingserver

        clientget('localhost', self.port, '/')
        target = ('localhost', 'port', '/') # non-numeric port
        try:
            with self.stderr_replaced():
                with self.loopingReactor():
                    while not exceptions:
                        pass
        except Exception, e:
            pass