def testStopTrying(self): f = Factory() f.protocol = In f.connections = 0 f.allMessages = [] c = ReconnectingClientFactory() c.initialDelay = c.delay = 0.2 c.protocol = Out c.howManyTimes = 2 port = reactor.listenTCP(0, f) PORT = port.getHost().port reactor.connectTCP('127.0.0.1', PORT, c) now = time.time() while len(f.allMessages) != 2 and (time.time() < now + 10): reactor.iterate(0.1) util.wait(defer.maybeDeferred(port.stopListening)) self.assertEquals(len(f.allMessages), 2, "not enough messages -- %s" % f.allMessages) self.assertEquals(f.connections, 2, "Number of successful connections incorrect %d" % f.connections) self.assertEquals(f.allMessages, [Out.msgs] * 2) self.failIf(c.continueTrying, "stopTrying never called or ineffective")
def loopback(server, client, logFile=None): """Run session between server and client. DEPRECATED in Twisted 2.5. Use loopbackAsync instead. """ import warnings warnings.warn('loopback() is deprecated (since Twisted 2.5). ' 'Use loopbackAsync() instead.', stacklevel=2, category=DeprecationWarning) from twisted.internet import reactor serverToClient = LoopbackRelay(client, logFile) clientToServer = LoopbackRelay(server, logFile) server.makeConnection(serverToClient) client.makeConnection(clientToServer) while 1: reactor.iterate(0.01) # this is to clear any deferreds serverToClient.clearBuffer() clientToServer.clearBuffer() if serverToClient.shouldLose: serverToClient.clearBuffer() server.connectionLost(failure.Failure(main.CONNECTION_DONE)) break elif clientToServer.shouldLose: client.connectionLost(failure.Failure(main.CONNECTION_DONE)) break reactor.iterate() # last gasp before I go away
def test_bind_noMatchingServicesFound_fallback_success(self): server = self.createServer( services=['svc1', 'svc2', 'svc3', ], fallback=True, responses=[ [ pureldap.LDAPSearchResultDone(ldaperrors.Success.resultCode) ], [ pureldap.LDAPSearchResultDone(ldaperrors.Success.resultCode) ], [ pureldap.LDAPSearchResultDone(ldaperrors.Success.resultCode) ], [ pureldap.LDAPBindResponse(resultCode=ldaperrors.Success.resultCode) ], ]) server.dataReceived(str(pureldap.LDAPMessage(pureldap.LDAPBindRequest(dn='cn=jack,dc=example,dc=com', auth='s3krit'), id=4))) reactor.iterate() #TODO client = server.client client.assertSent( pureldap.LDAPSearchRequest(baseObject='dc=example,dc=com', derefAliases=0, sizeLimit=0, timeLimit=0, typesOnly=0, filter=ldapfilter.parseFilter('(&' +'(objectClass=serviceSecurityObject)' +'(owner=cn=jack,dc=example,dc=com)' +'(cn=svc1)' +('(|(!(validFrom=*))(validFrom<=%s))' % server.now) +('(|(!(validUntil=*))(validUntil>=%s))' % server.now) +')'), attributes=('1.1',)), pureldap.LDAPSearchRequest(baseObject='dc=example,dc=com', derefAliases=0, sizeLimit=0, timeLimit=0, typesOnly=0, filter=ldapfilter.parseFilter('(&' +'(objectClass=serviceSecurityObject)' +'(owner=cn=jack,dc=example,dc=com)' +'(cn=svc2)' +('(|(!(validFrom=*))(validFrom<=%s))' % server.now) +('(|(!(validUntil=*))(validUntil>=%s))' % server.now) +')'), attributes=('1.1',)), pureldap.LDAPSearchRequest(baseObject='dc=example,dc=com', derefAliases=0, sizeLimit=0, timeLimit=0, typesOnly=0, filter=ldapfilter.parseFilter('(&' +'(objectClass=serviceSecurityObject)' +'(owner=cn=jack,dc=example,dc=com)' +'(cn=svc3)' +('(|(!(validFrom=*))(validFrom<=%s))' % server.now) +('(|(!(validUntil=*))(validUntil>=%s))' % server.now) +')'), attributes=('1.1',)), pureldap.LDAPBindRequest(dn='cn=jack,dc=example,dc=com', auth='s3krit')) self.assertEquals(server.transport.value(), str(pureldap.LDAPMessage(pureldap.LDAPBindResponse(resultCode=ldaperrors.Success.resultCode), id=4)))
def __try_import(packageName): #log.msg("try left "+str(retry)+" for package "+str(packageName)) imp = None async_call = 0 while imp == None: packageFile = packagename_to_packagefile(packageName) #log.msg(str(packageFile)) #log.msg("Loop") #if source file does not exist #log.msg("package file "+packageFile) if not (os.path.isfile('upload/' + packageFile) or os.path.isfile(packageFile)): #require it at first call if (async_call%20)==0: threads.deferToThread(__async_import, packageName) async_call+=1 reactor.iterate(4) else: try: #log.msg("try importing") imp = __import__(packageName) except (Exception): import traceback traceback.print_exc(file=sys.stdout) log.msg("Error during import") return None #log.msg(imp) #try to reimport it with a retry less #log.msg("Return __try_import "+str(imp)) return imp
def testPortforward(self): serverProtocol = wire.Echo() realServerFactory = protocol.ServerFactory() realServerFactory.protocol = lambda: serverProtocol realServerPort = reactor.listenTCP(0, realServerFactory, interface='127.0.0.1') proxyServerFactory = portforward.ProxyFactory('127.0.0.1', realServerPort.getHost().port) proxyServerPort = reactor.listenTCP(0, proxyServerFactory, interface='127.0.0.1') nBytes = 1000 received = [] clientProtocol = protocol.Protocol() clientProtocol.dataReceived = received.extend clientProtocol.connectionMade = lambda: clientProtocol.transport.write('x' * nBytes) clientFactory = protocol.ClientFactory() clientFactory.protocol = lambda: clientProtocol reactor.connectTCP('127.0.0.1', proxyServerPort.getHost().port, clientFactory) c = 0 while len(received) < nBytes and c < 100: reactor.iterate(0.01) c += 1 self.assertEquals(''.join(received), 'x' * nBytes) clientProtocol.transport.loseConnection() serverProtocol.transport.loseConnection() return defer.gatherResults([ defer.maybeDeferred(realServerPort.stopListening), defer.maybeDeferred(proxyServerPort.stopListening)])
def test_bind(self): server = self.createServer([ pureldap.LDAPBindResponse(resultCode=0), ]) server.dataReceived(str(pureldap.LDAPMessage(pureldap.LDAPBindRequest(), id=4))) reactor.iterate() #TODO self.assertEquals(server.transport.value(), str(pureldap.LDAPMessage(pureldap.LDAPBindResponse(resultCode=0), id=4)))
def testHeadRequest(self): self.testArticleRequest() index = self.result[0] try: del self.result except: pass try: del self.error except: pass d = self.backend.headRequest("alt.test.nntp", index) d.addCallbacks(self.callback, self.errback) id = reactor.callLater(5, self.timeout) while not hasattr(self, 'result') and not hasattr(self, 'error'): reactor.iterate() try: id.cancel() except ValueError: pass error = getattr(self, 'error', None) if error: raise error[0], error[1], error[2] self.failUnless(self.result[1] == MESSAGE_ID, "callback result Message-Id doesn't match: %s vs %s" % (MESSAGE_ID, self.result[1])) self.failUnless(self.result[2][-2:] == '\r\n', "headers must be \\r\\n terminated.")
def testDeferredFailure(self): def raiseError(): raise TypeError d = threads.deferToThread(raiseError) d.addErrback(self._resultErrback) while not self.gotResult: reactor.iterate() self.gotResult = 0
def buildProtocol(self, addr): p = TCPListener() ah = listenAirhookStream(randrange(10000,12000), UDPOutFactory(p)) reactor.iterate() c = ah.connectionForAddr(self.oaddr) #c.noisy= 1 return p
def runReactor(self, timesOrSeconds, seconds=False): """DEPRECATED: just return a deferred from your test method and trial with do the Right Thing. Alternatively, call twisted.trial.util.wait to block until the deferred fires. I'll iterate the reactor for a while. You probably want to use expectedAssertions with this. @type timesOrSeconds: int @param timesOrSeconds: Either the number of iterations to run, or, if `seconds' is True, the number of seconds to run for. @type seconds: bool @param seconds: If this is True, `timesOrSeconds' will be interpreted as seconds, rather than iterations. """ warnings.warn("runReactor is deprecated. return a deferred from " "your test method, and trial will wait for results." "Alternatively, call twisted.trial.util.wait to" "block until the deferred fires.", DeprecationWarning, stacklevel=2) from twisted.internet import reactor if seconds: reactor.callLater(timesOrSeconds, reactor.crash) reactor.run() return for i in xrange(timesOrSeconds): reactor.iterate()
def testOldAddress(self): server = Server() p = reactor.listenUDP(0, server, interface="127.0.0.1") reactor.iterate() addr = p.getHost() self.assertEquals(addr, ('INET_UDP', addr.host, addr.port)) p.stopListening()
def testRetr(self): # Connect client = ftp.FTPClient(passive=self.passive) factory = ClientFactory() factory.noisy = 0 factory.buildProtocol = lambda s, c=client: c reactor.connectTCP('localhost', self.ftp_port, factory) # download ftp_crap proto = BufferingProtocol() d = client.retr(os.path.basename('ftp_crap'), proto) d.addCallbacks(self.callback, self.errback) # Wait for a result id = reactor.callLater(5, self.errback, "timed out") # timeout so we don't freeze while not hasattr(self, 'result') and not hasattr(self, 'error'): reactor.iterate() try: id.cancel() except ValueError: pass error = getattr(self, 'error', None) if error: raise error[0], error[1], error[2] # Check that the file is the same as read directly off the disk self.failUnless(type(self.result) == types.ListType, 'callback result is wrong type: ' + str(self.result)) data = proto.buf.getvalue() self.failUnless(data == open('ftp_crap', "rb").read(), 'RETRieved file does not match original')
def testStor(self): # Connect client = ftp.FTPClient(passive=self.passive) client.debug = 1 factory = ClientFactory() factory.noisy = 0 factory.buildProtocol = lambda s, c=client: c reactor.connectTCP('localhost', self.ftp_port, factory) expectedContent = "Hello\n"*4 def gotResult(c): c.write(expectedContent) c.finish() def gotErr(f): self.errback(f) t = client.storeFile("HelloThere") t[0].addCallbacks(gotResult, gotErr) t[1].addCallbacks(self.callback, self.errback) # Wait for a result id = reactor.callLater(5, self.errback, "timed out") # timeout so we don't freeze while not hasattr(self, 'result') and not hasattr(self, 'error'): reactor.iterate() try: id.cancel() except ValueError: pass error = getattr(self, 'error', None) if error: raise error[0], error[1], error[2] self.assertEquals(open('HelloThere').read(), expectedContent)
def testCallLaterDelayAndReset(self): self._resetcallbackTime = None self._delaycallbackTime = None ireset = reactor.callLater(0.4, self._resetcallback) idelay = reactor.callLater(0.5, self._delaycallback) start = time.time() # chug a little before delaying while time.time() - start < 0.2: reactor.iterate(0.01) ireset.reset(0.4) # move expiration from 0.4 to (now)0.2+0.4=0.6 idelay.delay(0.3) # move expiration from 0.5 to (orig)0.5+0.3=0.8 # both should be called sometime during this while time.time() - start < 2: reactor.iterate(0.01) ireset_elapsed = self._resetcallbackTime - start idelay_elapsed = self._delaycallbackTime - start #self.assertApproximates(ireset_elapsed, 0.6, 0.4, # "ireset fired at %f (wanted 0.6)" % \ # ireset_elapsed) #self.assertApproximates(idelay_elapsed, 0.8, 0.4, # "idelay fired at %f (wanted 0.8)" % \ # idelay_elapsed) self.failUnless(idelay_elapsed >= ireset_elapsed, "got %f, %f" % (idelay_elapsed, ireset_elapsed)) self.failUnless(ireset_elapsed >= (0.6-0.05), "got %f (wanted 0.6)" % ireset_elapsed) self.failUnless(idelay_elapsed >= (0.8-0.05), "got %f (wanted 0.8)" % idelay_elapsed) del self._resetcallbackTime del self._delaycallbackTime
def testShortFileListings(self): # Connect client = ftp.FTPClient(passive=self.passive) factory = ClientFactory() factory.noisy = 0 factory.buildProtocol = lambda s, c=client: c reactor.connectTCP('localhost', self.ftp_port, factory) # Issue the command and set the callbacks p = BufferingProtocol() d = client.nlst('.', p) d.addCallbacks(self.callback, self.errback) # Wait for the result id = reactor.callLater(5, self.errback, "timed out") # timeout so we don't freeze while not hasattr(self, 'result') and not hasattr(self, 'error'): reactor.iterate() try: id.cancel() except ValueError: pass error = getattr(self, 'error', None) if error: raise error[0], error[1], error[2] # Check that the listing contains this file (ftp_crap) filenames = p.buf.getvalue().split('\r\n') self.failUnless('ftp_crap' in filenames, 'ftp_crap not in file listing')
def test_script_kill(self): self._skipCheck() try: result = yield self.db.script_kill() except redis.NoScriptRunning: pass except: raise self.failureException('%s raised instead of %s:\n %s' % (sys.exc_info()[0], 'txredisapi.NoScriptRunning', failure.Failure().getTraceback())) else: raise self.failureException('%s not raised (%r returned)' % ('txredisapi.ResponseError', result)) # Run an infinite loop script from one connection # and kill it from another. inf_loop = "while 1 do end" self.db1 = yield redis.Connection(REDIS_HOST, REDIS_PORT, reconnect=False) eval_deferred = self.db1.eval(inf_loop) reactor.iterate() r = yield self.db.script_kill() self.assertEqual(r, 'OK') try: result = yield eval_deferred except redis.ResponseError: pass except: raise self.failureException('%s raised instead of %s:\n %s' % (sys.exc_info()[0], 'txredisapi.ResponseError', failure.Failure().getTraceback())) else: raise self.failureException('%s not raised (%r returned)' % ('txredisapi.ResponseError', result))
def testArticleRequest(self): d = self.backend.articleRequest(None, None, MESSAGE_ID) d.addCallbacks(self.callback, self.errback) id = reactor.callLater(5, self.timeout) while not hasattr(self, 'result') and not hasattr(self, 'error'): reactor.iterate() try: id.cancel() except ValueError: pass error = getattr(self, 'error', None) if error: raise error[0], error[1], error[2] self.failUnless(type(self.result) == types.TupleType, 'callback result is wrong type: ' + str(self.result)) self.failUnless(len(self.result) == 3, 'callback result list should have three entries: ' + str(self.result)) self.failUnless(self.result[1] == MESSAGE_ID, "callback result Message-Id doesn't match: %s vs %s" % (MESSAGE_ID, self.result[1])) self.failUnless(self.result[2].find('\r\n\r\n'), "Can't find \\r\\n\\r\\n between header and body")
def testBodyRequest(self): self.testArticleRequest() index = self.result[0] try: del self.result except: pass try: del self.error except: pass d = self.backend.bodyRequest("alt.test.nntp", index) d.addCallbacks(self.callback, self.errback) id = reactor.callLater(5, self.timeout) while not hasattr(self, 'result') and not hasattr(self, 'error'): reactor.iterate() try: id.cancel() except ValueError: pass error = getattr(self, 'error', None) if error: raise error[0], error[1], error[2] self.failUnless(self.result[2][0:4] == 'this', "message body has been altered: " + pformat(self.result[2][0:4]))
def _shutdownTestReactor(self, prevent_stop=False): """ Called at the end of a test reactor run. When prevent_stop=True, the reactor will not be stopped. """ if not self._timeout_reached: # Everything fine, disable timeout. if not self._reactor_timeout_call.cancelled: self._reactor_timeout_call.cancel() if prevent_stop: # Don't continue with stop procedure. return # Let the reactor know that we want to stop reactor. reactor.stop() # Let the reactor run one more time to execute the stop code. reactor.iterate() # Set flag to fake a clean reactor. reactor._startedBefore = False reactor._started = False reactor._justStopped = False reactor.running = False # Start running has consumed the startup events, so we need # to restore them. reactor.addSystemEventTrigger( 'during', 'startup', reactor._reallyStartRunning)
def testHiddenException(self): import time cl = reactor.callLater(0, self.go) timeout = time.time() + 2 while not (self.finished or time.time() > timeout): reactor.iterate(0.1) self.failUnless(self.finished)
def setUp(self): CFTPClientTestBase.setUp(self) self.startServer() cmds = ('-p %i -l testuser ' '--known-hosts kh_test ' '--user-authentications publickey ' '--host-key-algorithms ssh-rsa ' '-K direct ' '-i dsa_test ' '-a --nocache ' '-v ' '127.0.0.1') port = self.server.getHost().port cmds = test_conch._makeArgs((cmds % port).split(), mod='cftp') log.msg('running %s %s' % (sys.executable, cmds)) self.processProtocol = SFTPTestProcess() env = os.environ.copy() env['PYTHONPATH'] = os.pathsep.join(sys.path) reactor.spawnProcess(self.processProtocol, sys.executable, cmds, env=env) timeout = time.time() + 10 while (not self.processProtocol.buffer) and (time.time() < timeout): reactor.iterate(0.1) if time.time() > timeout: self.skip = "couldn't start process" else: self.processProtocol.clearBuffer()
def _getBatchOutput(self, f): fn = tempfile.mktemp() open(fn, 'w').write(f) l = [] port = self.server.getHost().port cmds = ('-p %i -l testuser ' '--known-hosts kh_test ' '--user-authentications publickey ' '--host-key-algorithms ssh-rsa ' '-K direct ' '-i dsa_test ' '-a --nocache ' '-v -b %s 127.0.0.1') % (port, fn) cmds = test_conch._makeArgs(cmds.split(), mod='cftp')[1:] log.msg('running %s %s' % (sys.executable, cmds)) env = os.environ.copy() env['PYTHONPATH'] = os.pathsep.join(sys.path) d = getProcessOutputAndValue(sys.executable, cmds, env=env) d.setTimeout(10) d.addBoth(l.append) while not l: if hasattr(self.server.factory, 'proto'): self.server.factory.proto.expectedLoseConnection = 1 reactor.iterate(0.1) os.remove(fn) result = l[0] if isinstance(result, failure.Failure): raise result.value else: log.msg(result[1]) return result[0]
def testStoreRetrieve(self): for i in range(10): K = newID() V = newID() for a in range(3): self.done = 0 def _scb(key, value, result): self.done = 1 self.l[randrange(0, self.num)].storeValueForKey(K, V, _scb) while not self.done: reactor.iterate() def _rcb(key, val): if not val: self.done = 1 self.failUnlessEqual(self.got, 1) elif V in val: self.got = 1 for x in range(3): self.got = 0 self.done = 0 self.l[randrange(0, self.num)].valueForKey(K, _rcb) while not self.done: reactor.iterate()
def test_quit(self): """command quit""" # not using deferredResult here since it swallows timeout deferred = self.factory.check("quit") deferred.addCallback(self._assert_quit) while not self.done: reactor.iterate(0.1)
def testScheduling(self): c = Counter() for i in range(100): self.schedule(c.add) for i in range(100): reactor.iterate() self.assertEquals(c.index, 100)
def test_devicemap_as_deferred(self): """Return aggregated device map""" # safety timeout self.timeout = reactor.callLater(10, self.failed, "retrieving devicemap timed out ... failing") d = self.aggregator.getDeviceMap() assert isinstance(d, defer.Deferred) # caution: as this deferred is ready-to-go, the callback is called *immediately* d.addCallback(self.succeeded) # i.e., self.succeeded has now been called # idle until code above triggers succeeded or timeout causes failure while not self.done: reactor.iterate(0.1) # will arrive here eventually when either succeeded or failed method has fired if self.failure: self.failed(self.failure) devicemap = self.lastargs[0] print devicemap assert type(devicemap) == types.DictType assert len(devicemap) == 1 assert 'PseudoDevice' in devicemap assert len(devicemap['PseudoDevice']) == 2 assert 'Device1' in devicemap['PseudoDevice'] assert 'Device2' in devicemap['PseudoDevice']
def testNotRunAtOnce(self): c = Counter() self.schedule(c.add) # scheduled tasks should not be run at once: self.assertEquals(c.index, 0) reactor.iterate() self.assertEquals(c.index, 1)
def testDumber(self): filename = tempfile.mktemp() l = reactor.listenUNIX(filename, Factory()) reactor.connectUNIX(filename, TestClientFactory()) for i in xrange(100): reactor.iterate() l.stopListening()
def tearDown(self): self.clientPort.stopListening() self.serverPort.stopListening() for d, uri in self.registry.users.values(): d.cancel() reactor.iterate() reactor.iterate()
def _runTest(self, clientProto, serverProto, clientIsServer=False): self.clientProto = clientProto cf = self.clientFactory = protocol.ClientFactory() cf.protocol = lambda: clientProto if clientIsServer: cf.server = 0 else: cf.client = 1 self.serverProto = serverProto sf = self.serverFactory = protocol.ServerFactory() sf.protocol = lambda: serverProto if clientIsServer: sf.client = 0 else: sf.server = 1 if clientIsServer: inCharge = cf else: inCharge = sf inCharge.done = 0 port = self.port = reactor.listenTCP(0, sf, interface="127.0.0.1") portNo = port.getHost().port reactor.connectTCP('127.0.0.1', portNo, cf) i = 0 while i < 1000 and not inCharge.done: reactor.iterate(0.01) i += 1 self.failUnless( inCharge.done, "Never finished reading all lines: %s" % (inCharge.lines,))
def test3(self): ## add another that has to catch up ## add another self.a = self.l[0] self.b = Storer(self.group) reactor.listenWith(twispread.MultiPort, protocol=self.b) #self.b.log.addHandler(logging.StreamHandler()) #self.b.log.setLevel(logging.DEBUG) df = self.a.introduceNewServer(self.b.serverId) df.addCallback(self.done3) self.a.df.addCallback(self.done31) self.b.max = 5 for i in xrange(100): reactor.iterate(0.01) self.assertEqual(len(self.x), len(self.a.store)) self.assertEqual(self.a.store, self.b.store)
def test_unbind_clientEOF(self): server = self.createServer([ pureldap.LDAPBindResponse(resultCode=0), ], [], ) server.dataReceived(str(pureldap.LDAPMessage(pureldap.LDAPBindRequest(), id=2))) reactor.iterate() #TODO client = server.client client.assertSent(pureldap.LDAPBindRequest()) self.assertEqual(server.transport.value(), str(pureldap.LDAPMessage(pureldap.LDAPBindResponse(resultCode=0), id=2))) server.connectionLost(error.ConnectionDone) reactor.iterate() #TODO client.assertSent(pureldap.LDAPBindRequest(), 'fake-unbind-by-LDAPClientTestDriver') self.assertEqual(server.transport.value(), str(pureldap.LDAPMessage(pureldap.LDAPBindResponse(resultCode=0), id=2)))
def testClientStartStop(self): f = ClosingFactory() p = reactor.listenTCP(0, f, interface="127.0.0.1") self.n = p.getHost().port self.ports.append(p) f.port = p spinUntil(lambda: p.connected) factory = ClientStartStopFactory() reactor.connectTCP("127.0.0.1", self.n, factory) self.assert_(factory.started) reactor.iterate() reactor.iterate() spinUntil(lambda: factory.stopped) return self.cleanPorts(*self.ports)
def do_cleanPending(cls): # don't import reactor when module is loaded from twisted.internet import reactor # flush short-range timers reactor.iterate(0) reactor.iterate(0) pending = reactor.getDelayedCalls() if pending: s = PENDING_TIMED_CALLS_MSG for p in pending: s += " %s\n" % (p, ) if p.active(): p.cancel() # delete the rest else: print "WEIRNESS! pending timed call not active+!" raise PendingTimedCallsError(s)
def test_bind_sasl_no_credentials(self): # result code 14 is saslInprogress, with some server credentials. server = self.createServer([ pureldap.LDAPBindResponse(resultCode=14, serverSaslCreds='test123'), ]) server.dataReceived( pureldap.LDAPMessage(pureldap.LDAPBindRequest(auth=('GSS-SPNEGO', None), sasl=True), id=4).toWire()) reactor.iterate() #TODO self.assertEqual( server.transport.value(), pureldap.LDAPMessage(pureldap.LDAPBindResponse( resultCode=14, serverSaslCreds='test123'), id=4).toWire())
def _cleanPending(self): """ Cancel all pending calls and return their string representations. """ reactor = self._getReactor() # flush short-range timers reactor.iterate(0) reactor.iterate(0) delayedCallStrings = [] for p in reactor.getDelayedCalls(): if p.active(): delayedString = str(p) p.cancel() else: print("WEIRDNESS! pending timed call not active!") delayedCallStrings.append(delayedString) return delayedCallStrings
def spinWhile(f, timeout=DEFAULT_TIMEOUT_DURATION, msg="f did not return false before timeout"): """spin the reactor while condition returned by f() == True or until timeout seconds have elapsed i.e. spin until f() is False """ warnings.warn( "Do NOT use spinWhile. Return a Deferred from your " "test.", stacklevel=2, category=DeprecationWarning) assert callable(f) from twisted.internet import reactor now = time.time() stop = now + timeout while f(): if time.time() >= stop: raise defer.TimeoutError, msg reactor.iterate(0.1)
def testReadLimit(self): server = Server() c1, c2 = SimpleProtocol(), SimpleProtocol() now = time.time() tServer = policies.ThrottlingFactory(server, readLimit=10) port = reactor.listenTCP(0, tServer, interface="127.0.0.1") n = port.getHost()[2] self.doIterations() for c in c1, c2: reactor.connectTCP("127.0.0.1", n, SillyFactory(c)) self.doIterations() c1.transport.write("0123456789") c2.transport.write("abcdefghij") self.doIterations() self.assertEquals(c1.buffer, "0123456789") self.assertEquals(c2.buffer, "abcdefghij") self.assertEquals(tServer.readThisSecond, 20) # we wrote 20 bytes, so after one second it should stop reading # and then a second later start reading again while time.time() - now < 1.05: reactor.iterate() self.assertEquals(tServer.readThisSecond, 0) # write some more - data should *not* get written for another second c1.transport.write("0123456789") c2.transport.write("abcdefghij") self.doIterations() self.assertEquals(c1.buffer, "0123456789") self.assertEquals(c2.buffer, "abcdefghij") self.assertEquals(tServer.readThisSecond, 0) while time.time() - now < 2.05: reactor.iterate() self.assertEquals(c1.buffer, "01234567890123456789") self.assertEquals(c2.buffer, "abcdefghijabcdefghij") c1.transport.loseConnection() c2.transport.loseConnection() port.stopListening() for p in tServer.protocols.keys(): p.loseConnection() self.doIterations()
def loop(self, failMsg, cond=True, timeout=TIMEOUT): # Loops with a timeout self.done = False self.timeout = reactor.callLater(timeout, self.failed, "Timeout: " + failMsg) if cond == True: while not self.done: reactor.iterate(0.1) else: while self.done != cond: reactor.iterate(0.1) try: self.timeout.cancel() except (error.AlreadyCancelled, error.AlreadyCalled): pass if self.failure: self.fail(self.failure) if cond: self.failUnless((self.done == cond), "Failed: " + failMsg)
def update(self): self.milliseconds = self.pygame.time.get_ticks() #state machine if self.state == PlayerState.IDLE: if self.hardware.isWeaponButtonDown(0): self.shoot() self.handleHits() elif self.state == PlayerState.SHOOTING: #go back to idle state if the shot is over if self.milliseconds >= self.shotEnd: self.state = PlayerState.COOLDOWN self.cooldownEnd = self.milliseconds + self.cooldownDuration #TODO: reset hardware here later! self.handleHits() elif self.state == PlayerState.COOLDOWN: if self.milliseconds >= self.cooldownEnd: self.state = PlayerState.IDLE self.handleHits() elif self.state == PlayerState.DEAD: #reset hardware and jump to idle state if self.milliseconds >= self.deathEnd: self.state = PlayerState.IDLE self.hardware.setHitpointLED(i2cAddresses.HITPOINT_WEAPON, 0, 255, 0) # flush hits during death self.hardware.getWeaponHitResults() self.hardware.getHitpointResults(i2cAddresses.HITPOINT_WEAPON) #update stuff on the display self.display.redraw() #update/poll networking stuff print("Polling") self.networkclient.poll() if self.myid == 0: # if own playerid not yet set by the server self.onPlayerIdReceived(self.networkclient.getPlayerId()) if self.role == PlayerRole.SERVER: reactor.iterate()
def blockOn(self): """Call this to block and get the result of the wrapped Deferred. On success this will return the result. On failure, it will raise an exception. """ self.d.addCallback(self.gotResult) self.d.addErrback(self.gotFailure) while not self.finished: reactor.iterate(TIMEOUT) self.count += 1 if isinstance(self.d.result, dict): f = self.d.result.get('failure', None) if isinstance(f, failure.Failure): f.raiseException() return self.d.result
def resolve(self, names): """Resolves DNS names in parallel""" self._finished = False self.results = defaultdict(list) deferred_list = [] for name in names: for deferred in self.lookup(name): deferred.addCallback(self._extract_records, name) deferred.addErrback(self._errback, name) deferred_list.append(deferred) deferred_list = defer.DeferredList(deferred_list) deferred_list.addCallback(self._parse_result) deferred_list.addCallback(self._finish) while not self._finished: reactor.iterate() return dict(self.results)
def doSteps(self, steps=1): """ Returns true if the connection finished """ count = 0 while count < steps: reactor.iterate(0.01) self.con1ToCon2.clearBuffer() self.con2ToCon1.clearBuffer() if self.con1ToCon2.shouldLose: self.con1ToCon2.clearBuffer() count = -1 break elif self.con2ToCon1.shouldLose: count = -1 break else: count += 1 if count == -1: self.disconnect() return True return False
def loopback(server, client, logFile=None): """Run session between server and client. """ from twisted.internet import reactor serverToClient = LoopbackRelay(client, logFile) clientToServer = LoopbackRelay(server, logFile) server.makeConnection(serverToClient) client.makeConnection(clientToServer) while 1: reactor.iterate(0.01) # this is to clear any deferreds serverToClient.clearBuffer() clientToServer.clearBuffer() if serverToClient.shouldLose: serverToClient.clearBuffer() break elif clientToServer.shouldLose: break client.connectionLost(failure.Failure(main.CONNECTION_DONE)) server.connectionLost(failure.Failure(main.CONNECTION_DONE)) reactor.iterate() # last gasp before I go away
def loopbackTCP(server, client, port=0, noisy=True): """Run session between server and client protocol instances over TCP.""" from twisted.internet import reactor f = protocol.Factory() f.noisy = noisy f.buildProtocol = lambda addr, p=server: p serverPort = reactor.listenTCP(port, f, interface='127.0.0.1') reactor.iterate() clientF = LoopbackClientFactory(client) clientF.noisy = noisy reactor.connectTCP('127.0.0.1', serverPort.getHost().port, clientF) # this needs to wait until: # A: the client has disconnected # B: the server has noticed, and its own socket has disconnected # C: the listening socket has been shut down spinUntil(lambda: clientF.disconnected) # A spinWhile(lambda: server.transport.connected) # B serverPort.stopListening() spinWhile(lambda: serverPort.connected) # C
def testIt(self): p = self.l[0] self.words = ['foo', 'bar', 'bang'] for i in xrange(6): reactor.iterate(0.01) for w in self.words: p.transport.write(w, self.group) for i in xrange(10): reactor.doIteration(0.01) for p in self.l: p.store = [ msg for msg in p.store if type(msg) == spread.RegularMsgType ] self.failUnlessEqual(len(p.store), len(self.words)) for i in xrange(len(self.words)): for p in self.l: self.failUnlessEqual(p.store[i].message, self.words[i])
def testTcpNoDelay(self): f = MyServerFactory() port = reactor.listenTCP(0, f, interface="127.0.0.1") self.n = port.getHost().port self.ports.append(port) clientF = MyClientFactory() reactor.connectTCP("127.0.0.1", self.n, clientF) spinUntil(lambda: (f.called > 0 and getattr(clientF, 'protocol', None) is not None)) for p in clientF.protocol, f.protocol: transport = p.transport self.assertEquals(transport.getTcpNoDelay(), 0) transport.setTcpNoDelay(1) self.assertEquals(transport.getTcpNoDelay(), 1) transport.setTcpNoDelay(0) reactor.iterate() self.assertEquals(transport.getTcpNoDelay(), 0) return self.cleanPorts(clientF.protocol.transport, port)
def async_test(f, *args, **kwargs): "Starts an asynchronous test, waits for it to complete, and returns its result." result = [] def cb(value, good): result.append(good) result.append(value) inlineCallbacks(f)(*args, **kwargs).addCallbacks(callback=cb, callbackArgs=[True], errback=cb, errbackArgs=[False]) while not result: reactor.iterate(0.02) if result[0]: # Uncomment the following line to check that all the tests # really are being run to completion. #raise(Exception("Success")) return result[1] else: result[1].printTraceback() result[1].raiseException()
def wait(self, queues=None): stop = [False] def later(): stop[0] = True delayed_call = reactor.callLater(self.timeout, later) self.log_queues(queues) qa = self.queues_available(queues) while not qa and (not stop[0]): reactor.iterate(0.01) qa = self.queues_available(queues) if qa: delayed_call.cancel() e = self.pop_next (qa[0]) self.log_event (e) return e else: raise TimeoutError
def test_bind_match_success(self): server = self.createServer( services=['svc1', 'svc2', 'svc3', ], fallback=True, responses=[ # svc1 [ pureldap.LDAPSearchResultEntry(r'cn=svc1+owner=cn\=jack\,dc\=example\,dc\=com,dc=example,dc=com', attributes=[]), pureldap.LDAPSearchResultDone(ldaperrors.Success.resultCode) ], [ pureldap.LDAPBindResponse(resultCode=ldaperrors.Success.resultCode) ], ]) server.dataReceived(str(pureldap.LDAPMessage(pureldap.LDAPBindRequest(dn='cn=jack,dc=example,dc=com', auth='secret'), id=4))) reactor.iterate() #TODO client = server.client client.assertSent( pureldap.LDAPSearchRequest(baseObject='dc=example,dc=com', derefAliases=0, sizeLimit=0, timeLimit=0, typesOnly=0, filter=ldapfilter.parseFilter('(&' +'(objectClass=serviceSecurityObject)' +'(owner=cn=jack,dc=example,dc=com)' +'(cn=svc1)' +('(|(!(validFrom=*))(validFrom<=%s))' % server.now) +('(|(!(validUntil=*))(validUntil>=%s))' % server.now) +')'), attributes=('1.1',)), pureldap.LDAPBindRequest(dn=r'cn=svc1+owner=cn\=jack\,dc\=example\,dc\=com,dc=example,dc=com', auth='secret'), ) self.assertEquals(server.transport.value(), str(pureldap.LDAPMessage(pureldap.LDAPBindResponse(resultCode=ldaperrors.Success.resultCode, matchedDN='cn=jack,dc=example,dc=com'), id=4)))
def test_script_kill(self): self._skipCheck() try: result = yield self.db.script_kill() except trex.exceptions.NoScriptRunning: pass except: raise self.failureException( '%s raised instead of %s:\n %s' % (sys.exc_info()[0], 'trex.exceptions.NoScriptRunning', failure.Failure().getTraceback())) else: raise self.failureException( '%s not raised (%r returned)' % ('trex.exceptions.ResponseError', result)) # Run an infinite loop script from one connection # and kill it from another. inf_loop = "while 1 do end" self.db1 = yield redis.Connection(REDIS_HOST, REDIS_PORT, reconnect=False) eval_deferred = self.db1.eval(inf_loop) reactor.iterate() r = yield self.db.script_kill() self.assertEqual(r, 'OK') try: result = yield eval_deferred except trex.exceptions.ResponseError: pass except: raise self.failureException( '%s raised instead of %s:\n %s' % (sys.exc_info()[0], 'trex.exceptions.ResponseError', failure.Failure().getTraceback())) else: raise self.failureException( '%s not raised (%r returned)' % ('trex.exceptions.ResponseError', result))
def testOpenSSLBuffering(self): serverProto = self.serverProto = SingleLineServerProtocol() clientProto = self.clientProto = RecordingClientProtocol() server = protocol.ServerFactory() client = self.client = protocol.ClientFactory() server.protocol = lambda: serverProto client.protocol = lambda: clientProto client.buffer = [] sCTX = ssl.DefaultOpenSSLContextFactory(certPath, certPath) cCTX = ssl.ClientContextFactory() port = self.port = reactor.listenSSL(0, server, sCTX, interface='127.0.0.1') reactor.connectSSL('127.0.0.1', port.getHost().port, client, cCTX) i = 0 while i < 5000 and not client.buffer: i += 1 reactor.iterate() self.assertEquals(client.buffer, ["+OK <some crap>\r\n"])
def resolve(self, names): """Resolves DNS names in parallel""" self._finished = False self.results = defaultdict(list) deferred_list = [] for name in names: for deferred in self.lookup(name): deferred.addCallback(self._extract_records, name) deferred.addErrback(self._errback, name) deferred_list.append(deferred) deferred_list = defer.DeferredList(deferred_list) deferred_list.addCallback(self._parse_result) deferred_list.addCallback(self._finish) while not self._finished: reactor.iterate() # Although the results are in at this point, we may need an extra # iteration to ensure the resolver library closes its UDP sockets reactor.iterate() return dict(self.results)
def testCorrectOrder(self): o = Order() self.schedule(o.a) self.schedule(o.b) self.schedule(o.c) reactor.iterate() reactor.iterate() reactor.iterate() self.assertEquals(o.stage, 3)
def command(player, command, args): if command == 'stop': player.kick_all('Server stopped') plugin.log(player.username + ' has stopped server') time.sleep(1) from twisted.internet import reactor reactor.removeAll() reactor.iterate() reactor.stop() if command == 'tp': if len(args) == 3: x, y, z = args[0], args[1], args[2] player.set_position(x, y, z) player.send_chat('Teleported to X:%s Y:%s Z:%s' % (str(x), str(y), str(z))) else: player.send_chat('Need 3 args: x,y,z') if command == 'item' or command == 'give': if len(args) == 3: id, count, slot = int(args[0]), int(args[1]), int(args[2]) player.send_set_slot(id, count, slot) else: player.send_chat('3 args need') if command == 'help': player.send_chat( '/tp [x, y, z]\n/stop\n/title line1 line2 2\n/give id count slot') if command == 'title': if len(args) == 3: player.send_title(args[0], args[1], 25, int(args[2]) * 25, 25) else: player.send_chat('3 args need') if command == 'brodcast' or command == 'bc': if len(args) == 0: player.send_chat('Enter your message') else: player.send_chat_all(''.join(args))
def handler(player, command, args): if command == "stop": player.send_chat("Server stopping... You will be kicked in two seconds") time.sleep(2) plugin.log(player.nickname + " has stopped the server!") from twisted.internet import reactor # Import reactor and call stop methods reactor.removeAll() reactor.iterate() reactor.stop() if command == "tppos": # If command called with 3 arguments if len(args) == 3: # Set player position try: x, y, z = [float(arg) for arg in args] # Convert strings to floats player.set_position(x, y, z) player.send_chat("Teleported to X:{0} Y:{1} Z:{2} successfully".format(x, y, z)) except ValueError: # If we can't convert it player.send_chat("You need to supply numbers!") else: player.send_chat("tppos takes 3 arguments: x,y,z") if command == "help": # TODO: Make something useful here player.send_chat("There's nothing here, sorry :(")
def setUp(self): self.group = 'test-' + ''.join( [chr(random.randint(0, 255)) for x in range(4)]).encode('hex') self.a = hashtable.ReplicatedDict(self.group, ':memory:', random.randint(10000, 64000)) reactor.iterate(0.01) reactor.iterate(0.01) reactor.iterate(0.01) self.b = hashtable.ReplicatedDict(self.group, ':memory:', random.randint(10000, 64000), 'localhost:%s' % self.a.port)
def testCallInNextIteration(self): calls = [] def f1(): calls.append('f1') reactor.callLater(0.0, f2) def f2(): calls.append('f2') reactor.callLater(0.0, f3) def f3(): calls.append('f3') reactor.callLater(0, f1) self.assertEquals(calls, []) reactor.iterate() self.assertEquals(calls, ['f1']) reactor.iterate() self.assertEquals(calls, ['f1', 'f2']) reactor.iterate() self.assertEquals(calls, ['f1', 'f2', 'f3'])
def tearDown(self): self.port.stopListening() reactor.iterate() reactor.iterate() del self.port
def run(self): try: reactor.iterate(conf.supybot.drivers.poll()) except: drivers.log.exception('Uncaught exception outside reactor:')