def test_twisted_schedule_action(self):
        scheduler = TwistedScheduler(reactor)
        ran = [False]

        def action(scheduler, state):
            ran[0] = True
        disposable = scheduler.schedule(action)

        promise = defer.Deferred()
        def done():
            assert(ran[0] == True)
            promise.callback("Done")
        reactor.callLater(0.1, done)
        yield promise
    def test_twisted_schedule_action_cancel(self):
        ran = [False]
        scheduler = TwistedScheduler(reactor)

        def action(scheduler, state):
            ran[0] = True
        d = scheduler.schedule_relative(0.01, action)
        d.dispose()

        promise = defer.Deferred()
        def done():
            assert(not ran[0])
            promise.callback("Done")
        reactor.callLater(0.1, done)

        yield promise
Exemple #3
0
    def test_twisted_schedule_action(self):
        scheduler = TwistedScheduler(reactor)
        ran = [False]

        def action(scheduler, state):
            ran[0] = True

        disposable = scheduler.schedule(action)

        promise = defer.Deferred()

        def done():
            assert (ran[0] == True)
            promise.callback("Done")

        reactor.callLater(0.1, done)
        yield promise
    def test_twisted_schedule_action_due(self):
        scheduler = TwistedScheduler(reactor)
        starttime = reactor.seconds()
        endtime = [None]

        def action(scheduler, state):
            endtime[0] = reactor.seconds()

        scheduler.schedule_relative(0.2, action)

        promise = defer.Deferred()
        def done():
            diff = endtime[0]-starttime
            assert(diff > 0.18)
            promise.callback("Done")
        reactor.callLater(0.3, done)
        yield promise
Exemple #5
0
    def test_twisted_schedule_action_cancel(self):
        ran = [False]
        scheduler = TwistedScheduler(reactor)

        def action(scheduler, state):
            ran[0] = True

        d = scheduler.schedule_relative(0.01, action)
        d.dispose()

        promise = defer.Deferred()

        def done():
            assert (not ran[0])
            promise.callback("Done")

        reactor.callLater(0.1, done)

        yield promise
Exemple #6
0
    def test_twisted_schedule_action_due(self):
        scheduler = TwistedScheduler(reactor)
        starttime = reactor.seconds()
        endtime = [None]

        def action(scheduler, state):
            endtime[0] = reactor.seconds()

        scheduler.schedule_relative(0.2, action)

        promise = defer.Deferred()

        def done():
            diff = endtime[0] - starttime
            assert (diff > 0.18)
            promise.callback("Done")

        reactor.callLater(0.3, done)
        yield promise
Exemple #7
0
# coding=utf-8
from StringIO import StringIO
from datetime import timedelta

from rx import Observer
from rx.concurrency import TwistedScheduler
from rx.disposables import Disposable
from rx.subjects import Subject
from twisted.internet.protocol import Factory, Protocol, connectionDone
from twisted.internet.endpoints import TCP4ServerEndpoint
from twisted.internet import reactor

scheduler = TwistedScheduler(reactor)  # using this to schedule timeouts

KEEP_ALIVE_TIMEOUT = 10  # seconds
READ_TIMEOUT = 5  # seconds


class HttpConnection(Protocol):  # Protocol for Twisted
    listener = Subject()  # shared by all connections

    def connectionMade(self):
        self.data_in = Subject()
        self.listener.on_next(self)

    def connectionLost(self, reason=connectionDone):
        self.data_in.on_completed()

    def dataReceived(self, data):
        self.data_in.on_next(data)
Exemple #8
0
 def test_twisted_schedule_now(self):
     scheduler = TwistedScheduler(reactor)
     res = scheduler.now() - datetime.now()
     assert (res < timedelta(seconds=1))
 def test_twisted_schedule_now(self):
     scheduler = TwistedScheduler(reactor)
     res = scheduler.now() - datetime.now()
     assert(res < timedelta(seconds=1))
 def test_twisted_schedule_now(self):
     scheduler = TwistedScheduler(reactor)
     res = datetime.fromtimestamp(scheduler.now()) - datetime.utcnow()
     assert(res < timedelta(seconds=1))