def poll(self, noLongerThan=1.0): # poll the reactor for up to noLongerThan seconds base = seconds() try: while (seconds() - base) <= noLongerThan: callback = self.twistedQueue.get_nowait() callback() except Empty: pass
def simulate(self): """Run simulation loops and reschedule callbacks. """ if self.running: t = 0.01 start = seconds() while t > 0: self.iterate(t) t = 0.01 - (seconds() - start)
def scheduleAutoDeal(self): self.cancelDealTimeout() if self.factory.shutting_down: self.log.debug("Not autodealing because server is shutting down") return False if not self.autodeal: self.log.debug("No autodeal") return False if self.isRunning(): self.log.debug("Not autodealing %d because game is running", self.game.id) return False if self.game.state == pokergame.GAME_STATE_MUCK: self.log.debug("Not autodealing %d because game is in muck state", self.game.id) return False if self.game.sitCount() < 2: self.log.debug("Not autodealing %d because less than 2 players willing to play", self.game.id) return False if self.game.isTournament(): if self.tourney: if self.tourney.state != pokertournament.TOURNAMENT_STATE_RUNNING: self.log.debug("Not autodealing %d because in tournament state %s", self.game.id, self.tourney.state) if self.tourney.state == pokertournament.TOURNAMENT_STATE_BREAK_WAIT: self.broadcastMessage(PacketPokerGameMessage, "Tournament will break when the other tables finish their hand") return False elif not self.autodeal_temporary: # # Do not auto deal a table where there are only temporary # users (i.e. bots) # only_temporary_users = True for serial in self.game.serialsSit(): if not self.factory.isTemporaryUser(serial): only_temporary_users = False break if only_temporary_users: self.log.debug("Not autodealing because players are categorized as temporary") return False delay = self.game_delay["delay"] if not self.allReadyToPlay() and delay > 0: delta = (self.game_delay["start"] + delay) - seconds() autodeal_max = float(self.delays.get("autodeal_max", 120)) delta = min(autodeal_max, max(0, delta)) self.game_delay["delay"] = (seconds() - self.game_delay["start"]) + delta elif self.transient: delta = int(self.delays.get("autodeal_tournament_min", 15)) if seconds() - self.game_delay["start"] > delta: delta = 0 else: delta = 0 self.log.debug("AutodealCheck scheduled in %f seconds", delta) autodeal_check = max(0.01, float(self.delays.get("autodeal_check", 15))) self.timer_info["dealTimeout"] = reactor.callLater(min(autodeal_check, delta), self.autoDealCheck, autodeal_check, delta) return True
def _start(self, duration, *args, **kwargs): self.stop() self.duration = duration self.running = True self.timer_end = reactor.callLater(self.duration, self.end, *args, **kwargs) self.start_time = seconds() self.current_time = seconds() self.end_time = seconds() + duration self.start(*args, **kwargs) if self.verbose > 2: self.message("_start %d" % duration) self._run(*args, **kwargs)
def _run(self, *args, **kwargs): delta = seconds() - self.current_time self.current_time += delta self.fraction_from_start = ( self.current_time - self.start_time ) / self.duration self.fraction_to_end = 1.0 - self.fraction_from_start self.run(delta, *args, **kwargs) now = seconds() next_time = min(self.end_time, now + self.step) if next_time > self.end_time: next_time = self.end_time delay = next_time - now if delay > 0.0: self.timer = reactor.callLater(delay, self._run, *args, **kwargs) else: self.stop()
def sendPacketData(self, data): self.log.debug("sendPacketData %s", data) factory = RestClientFactory(self.host, self.port, self.path, data, self.timeout) reactor.connectTCP(self.host, self.port, factory) self.sentTime = seconds() return factory.deferred
def sendPacketData(self, data): if self.verbose > 3: self.message('sendPacketData ' + data) factory = RestClientFactory(self.host, self.port, self.path, data, self.timeout) reactor.connectTCP(self.host, self.port, factory) self.sentTime = seconds() return factory.deferred
def reset(self, secondsFromNow): """Reschedule this call for a different time @type secondsFromNow: C{float} @param secondsFromNow: The number of seconds from the time of the C{reset} call at which this call will be scheduled. @raise AlreadyCancelled: Raised if this call has been cancelled. @raise AlreadyCalled: Raised if this call has already been made. """ if self.cancelled: raise error.AlreadyCancelled elif self.called: raise error.AlreadyCalled else: if self.seconds is None: new_time = seconds() + secondsFromNow else: new_time = self.seconds() + secondsFromNow if new_time < self.time: self.delayed_time = 0 self.time = new_time self.resetter(self) else: self.delayed_time = new_time - self.time
def check(self): """Periodically called method that does a single uptime check.""" if not self.active: log.warn( "ProxyFetchMonitoringProtocol.check() called while active == False" ) return # FIXME: Use GET as a workaround for a Twisted bug with HEAD/Content-length # where it expects a body and throws a PartialDownload failure url = random.choice(self.URL) self.checkStartTime = seconds() self.getPageDeferred = self.getProxyPage( url, method='GET', host=self.server.ip, port=self.server.port, status=self.expectedStatus, timeout=self.toGET, followRedirect=False, reactor=self.reactor).addCallbacks(self._fetchSuccessful, self._fetchFailed).addBoth( self._checkFinished) return self.getPageDeferred
def setPlayerDelay(self, game, serial, value): player = game.getPlayer(serial) if player == None: self.message( "WARNING setPlayerDelay for a non-existing player %d" % serial) else: player.getUserData()['delay'] = seconds() + value
def test01_add_message(self): # new instance of the chat plugin to test chat_instance = Plugin(self.service, []) # create a message event request player_id = 200 sentence = "This is my sentence!" now = int(runtime.seconds() * 1000) request = Request(action=['message'], player_id=[player_id], sentence=[sentence]) # verify we have no messages yet self.assertEquals(len(chat_instance.messages), 0) # run the request result = yield chat_instance.preprocess(True, request) # verify we now have one message self.assertEquals(len(chat_instance.messages), 1) # verify the event has been removed from the pipeline self.assertFalse(request.args.has_key('action')) # verify the message we added is in the list self.assertEquals(chat_instance.messages[0]["player_id"], player_id) self.assertEquals(chat_instance.messages[0]["sentence"], sentence) # check that the message has been recorded in log file with open(os.path.join(self.test_logdir, 'chat', '%s.log' % strftime('%Y-%m-%d'))) as f: lines = f.readlines() self.assertEquals(len(lines), 1) self.assertIn(sentence, lines[0]) self.assertIn('player_%d' % player_id, lines[0])
def publishPackets(self): if not self._poll: return delay = 0.01 if len(self.publish_packets) > 0: # # If time has not come, make sure we are called at a later time # to reconsider the situation # wait_for = self.publish_time - seconds() if wait_for > 0: self.log.debug("publishPacket: %f before next packet is sent", wait_for) delay = wait_for self.block() else: self.publishPacket() if len(self.publish_packets) > 0: self.block() else: self.unblock() else: self.unblock() self.publishPacketTriggerTimer(delay)
def publishPackets(self): if not self._poll: return delay = 0.01 if len(self.publish_packets) > 0: # # If time has not come, make sure we are called at a later time # to reconsider the situation # wait_for = self.publish_time - seconds() if wait_for > 0: if self.factory.verbose > 2: self.message("publishPackets: %f before next packet is sent" % wait_for) delay = wait_for self.block() else: self.publishPacket() if len(self.publish_packets) > 0: self.block() else: self.unblock() else: self.unblock() self.publishPacketTriggerTimer(delay)
def setPlayerDelay(self, game, serial, value): player = game.getPlayer(serial) if player == None: self.log.warn("setPlayerDelay for a non-existing player %d", serial) else: player.getUserData()['delay'] = seconds() + value
def start(self, interval, now=True): """Start running function every interval seconds. @param interval: The number of seconds between calls. May be less than one. Precision will depend on the underlying platform, the available hardware, and the load on the system. @param now: If True, run this call right now. Otherwise, wait until the interval has elapsed before beginning. @return: A Deferred whose callback will be invoked with C{self} when C{self.stop} is called, or whose errback will be invoked if the function raises an exception. """ assert not self.running, ("Tried to start an already running " "LoopingCall.") if interval < 0: raise ValueError, "interval must be >= 0" self.running = True d = self.deferred = defer.Deferred() self.starttime = seconds() self.count = 0 self.interval = interval if now: self() else: self._reschedule() return d
def testFetchSuccessful(self): testResult = "Test page result" self.monitor.checkStartTime = seconds() with mock.patch.object(self.monitor, '_resultUp') as mock_resultUp: r = self.monitor._fetchSuccessful(testResult) mock_resultUp.assert_called_once() self.assertIs(r, testResult)
def _fetchSuccessful(self, result): """Called when getProxyPage is finished successfully.""" self.report('Fetch successful, {0:.3f} s'.format((seconds() - self.checkStartTime))) self._resultUp() return result
def testFetchFailed(self): testMessage = "Testing failed fetches" testFailure = failure.Failure(defer.TimeoutError(testMessage)) self.monitor.checkStartTime = seconds() with mock.patch.object(self.monitor, '_resultDown') as mock_resultDown: self.monitor._fetchFailed(testFailure) mock_resultDown.assert_called_once()
def processEnded(self, reason): """ Called when the process has ended """ duration = seconds() - self.checkStartTime if reason.check(error.ProcessDone): self._resultUp() result = 'successful' exitcode = 0 elif reason.check(error.ProcessTerminated): self._resultDown(reason.getErrorMessage()) result = 'failed' exitcode = reason.value.exitCode else: result = None exitcode = None self.runcommand_metrics['run_duration_seconds'].labels( result=result, exitcode=exitcode, **self.metric_labels ).set(duration) self.runningProcessDeferred.callback(reason.type) reason.trap(error.ProcessDone, error.ProcessTerminated)
def testCheck(self): startSeconds = seconds() self.monitor.active = True with mock.patch.multiple(self.monitor, getProxyPage=mock.DEFAULT, _fetchSuccessful=mock.DEFAULT, _fetchFailed=mock.DEFAULT, _checkFinished=mock.DEFAULT) as mocks: mocks['getProxyPage'].return_value = defer.Deferred() d = self.monitor.check() self.assertIsInstance(d, defer.Deferred) self.assertGreaterEqual(self.monitor.checkStartTime, startSeconds) # Check getProxyPage keyword arguments kwargs = mocks['getProxyPage'].call_args[1] self.assertEqual(kwargs['method'], "GET") self.assertEqual(kwargs['host'], self.server.ip) self.assertEqual(kwargs['port'], self.server.port) self.assertEqual(kwargs['status'], self.monitor.expectedStatus) self.assertEqual(kwargs['timeout'], self.monitor.toGET) self.assertFalse(kwargs['followRedirect']) # Check whether the callback works testResult = "Test page" self.monitor.getPageDeferred.callback(testResult) mocks['_fetchSuccessful'].assert_called_once_with(testResult) mocks['_fetchFailed'].assert_not_called() mocks['_checkFinished'].assert_called()
def processEnded(self, reason): """ Called when the process has ended """ duration = seconds() - self.checkStartTime if reason.check(error.ProcessDone): self._resultUp() result = 'successful' exitcode = 0 elif reason.check(error.ProcessTerminated): self._resultDown(reason.getErrorMessage()) result = 'failed' exitcode = reason.value.exitCode else: result = None exitcode = None self.runcommand_metrics['run_duration_seconds'].labels( result=result, exitcode=exitcode, **self.metric_labels ).set(duration) # Schedule the next check if self.active: self.checkCall = reactor.callLater(self.intvCheck, self.runCommand) reason.trap(error.ProcessDone, error.ProcessTerminated)
def test01_add_message(self): # new instance of the chat plugin to test chat_instance = Plugin(self.service, []) # create a message event request player_id = 200 sentence = "This is my sentence!" now = int(runtime.seconds() * 1000) request = Request(action=['message'], player_id=[player_id], sentence=[sentence]) # verify we have no messages yet self.assertEquals(len(chat_instance.messages), 0) # run the request result = yield chat_instance.preprocess(True, request) # verify we now have one message self.assertEquals(len(chat_instance.messages), 1) # verify the event has been removed from the pipeline self.assertFalse(request.args.has_key('action')) # verify the message we added is in the list self.assertEquals(chat_instance.messages[0]["player_id"], player_id) self.assertEquals(chat_instance.messages[0]["sentence"], sentence) # check that the message has been recorded in log file with open( os.path.join(self.test_logdir, 'chat', '%s.log' % strftime('%Y-%m-%d'))) as f: lines = f.readlines() self.assertEquals(len(lines), 1) self.assertIn(sentence, lines[0]) self.assertIn('player_%d' % player_id, lines[0])
def __str__(self): if self._str is not None: return self._str if hasattr(self, 'func'): if hasattr(self.func, 'func_name'): func = self.func.func_name if hasattr(self.func, 'im_class'): func = self.func.im_class.__name__ + '.' + func else: func = reflect.safe_repr(self.func) else: func = None if self.seconds is None: now = seconds() else: now = self.seconds() L = ["<DelayedCall %s [%ss] called=%s cancelled=%s" % ( id(self), self.time - now, self.called, self.cancelled)] if func is not None: L.extend((" ", func, "(")) if self.args: L.append(", ".join([reflect.safe_repr(e) for e in self.args])) if self.kw: L.append(", ") if self.kw: L.append(", ".join(['%s=%s' % (k, reflect.safe_repr(v)) for (k, v) in self.kw.iteritems()])) L.append(")") if self.debug: L.append("\n\ntraceback at creation: \n\n%s" % (' '.join(self.creator))) L.append('>') return "".join(L)
def test05_check_half_of_multiple_messages(self): # new instance of the chat plugin to test chat_instance = Plugin(self.service, []) # create a message event request player_ids = [200, 220, 999] sentences = [ "This is my sentence!", "Yeah another test hello.", "Ping ping poing pong." ] when = [] for i in range(3): sleep(0.1) when.append(int(runtime.seconds() * 1000)) request = Request(action=['message'], player_id=[player_ids[i]], sentence=[sentences[i]]) # run the request result = yield chat_instance.preprocess(True, request) # check to make sure no message is returned if we ask for now or later # we check right back to one second ago to make sure all recently added messages are caught state, players_id_list = yield chat_instance.state( {"modified": [when[-1] - 150]}) # this time because of the 100ms delay between messages, and only checking to 150ms ago # we should only get the last two messages self.assertEquals(len(state['messages']), 2) for i in range(2): self.assertEquals(state['messages'][i]['player_id'], player_ids[i + 1]) self.assertEquals(state['messages'][i]['sentence'], sentences[i + 1]) self.assertEquals(players_id_list, player_ids[-2:])
def check(self): """Periodically called method that does a single uptime check.""" if not self.active: log.warn("ProxyFetchMonitoringProtocol.check() called while active == False") return # FIXME: Use GET as a workaround for a Twisted bug with HEAD/Content-length # where it expects a body and throws a PartialDownload failure url = random.choice(self.URL) self.checkStartTime = seconds() self.getPageDeferred = self.getProxyPage( url, method='GET', host=self.server.ip, port=self.server.port, status=self.expectedStatus, timeout=self.toGET, followRedirect=False ).addCallbacks( self._fetchSuccessful, self._fetchFailed ).addBoth(self._checkFinished)
def _queryFailed(self, failure, query): """Called when the DNS query finished with a failure.""" queryStr = ", query: %s %s" % (query.name, dns.QUERY_TYPES[query.type]) # Don't act as if the check failed if we cancelled it if failure.check(defer.CancelledError): return None elif failure.check(error.DNSQueryTimeoutError): errorStr = "DNS query timeout" + queryStr elif failure.check(error.DNSServerError): errorStr = "DNS server error" + queryStr elif failure.check(error.DNSNameError): errorStr = "%s NXDOMAIN" % query.name if not self.failOnNXDOMAIN: self.report(errorStr, level=logging.INFO) self._resultUp() return None elif failure.check(error.DNSQueryRefusedError): errorStr = "DNS query refused" + queryStr else: errorStr = str(failure) duration = runtime.seconds() - self.checkStartTime self.report('DNS query failed, %.3f s' % (duration), level=logging.ERROR) self._resultDown(errorStr) self.dnsquery_metrics['request_duration_seconds'].labels( result='failed', **self.metric_labels).set(duration) failure.trap(*self.catchList)
def _queryFailed(self, failure, query): """Called when the DNS query finished with a failure.""" queryStr = ", query: %s %s" % (query.name, dns.QUERY_TYPES[query.type]) # Don't act as if the check failed if we cancelled it if failure.check(defer.CancelledError): return None elif failure.check(error.DNSQueryTimeoutError): errorStr = "DNS query timeout" + queryStr elif failure.check(error.DNSServerError): errorStr = "DNS server error" + queryStr elif failure.check(error.DNSNameError): errorStr = "%s NXDOMAIN" % query.name if not self.failOnNXDOMAIN: self.report(errorStr, level=logging.INFO) self._resultUp() return None elif failure.check(error.DNSQueryRefusedError): errorStr = "DNS query refused" + queryStr else: errorStr = str(failure) self.report( 'DNS query failed, %.3f s' % (runtime.seconds() - self.checkStartTime), level=logging.ERROR ) self._resultDown(errorStr) failure.trap(*self.catchList)
def runUntilCurrent(self): """Run all pending timed calls. """ if self.threadCallQueue: # Keep track of how many calls we actually make, as we're # making them, in case another call is added to the queue # while we're in this loop. count = 0 total = len(self.threadCallQueue) for (f, a, kw) in self.threadCallQueue: try: f(*a, **kw) except: log.err() count += 1 if count == total: break del self.threadCallQueue[:count] if self.threadCallQueue: if self.waker: self.waker.wakeUp() # insert new delayed calls now self._insertNewDelayedCalls() now = seconds() while self._pendingTimedCalls and (self._pendingTimedCalls[0].time <= now): call = heappop(self._pendingTimedCalls) if call.cancelled: self._cancellations -= 1 continue if call.delayed_time > 0: call.activate_delay() heappush(self._pendingTimedCalls, call) continue try: call.called = 1 call.func(*call.args, **call.kw) except: log.deferr() if hasattr(call, "creator"): e = "\n" e += " C: previous exception occurred in " + \ "a DelayedCall created here:\n" e += " C:" e += "".join(call.creator).rstrip().replace("\n", "\n C:") e += "\n" log.msg(e) if (self._cancellations > 50 and self._cancellations > len(self._pendingTimedCalls) >> 1): self._cancellations = 0 self._pendingTimedCalls = [ x for x in self._pendingTimedCalls if not x.cancelled ] heapify(self._pendingTimedCalls)
def runUntilCurrent(self): """Run all pending timed calls. """ if self.threadCallQueue: # Keep track of how many calls we actually make, as we're # making them, in case another call is added to the queue # while we're in this loop. count = 0 total = len(self.threadCallQueue) for (f, a, kw) in self.threadCallQueue: try: f(*a, **kw) except: log.err() count += 1 if count == total: break del self.threadCallQueue[:count] if len(self.threadCallQueue) > 0: if self.waker: self.waker.wakeUp() # insert new delayed calls now self._insertNewDelayedCalls() now = seconds() while self._pendingTimedCalls and (self._pendingTimedCalls[0].time <= now): call = heappop(self._pendingTimedCalls) if call.cancelled: self._cancellations-=1 continue if call.delayed_time > 0: call.activate_delay() heappush(self._pendingTimedCalls, call) continue try: call.called = 1 call.func(*call.args, **call.kw) except: log.deferr() if hasattr(call, "creator"): e = "\n" e += " C: previous exception occurred in " + \ "a DelayedCall created here:\n" e += " C:" e += "".join(call.creator).rstrip().replace("\n","\n C:") e += "\n" log.msg(e) if (self._cancellations > 50 and self._cancellations > len(self._pendingTimedCalls) >> 1): self._cancellations = 0 self._pendingTimedCalls = [x for x in self._pendingTimedCalls if not x.cancelled] heapify(self._pendingTimedCalls)
def setPlayerTimeout(self, game, packet): if packet.timeout > 0: packet.when = int(seconds()) player = game.getPlayer(packet.serial) player.getUserData()['timeout'] = (packet.when, packet.timeout) return True else: return False
def connectionRefused(self): """Called if an ICMP destination unreachable is received""" self.last_down_timestamp = runtime.seconds() self._resultDown() self.report("{} ICMP destination unreachable received".format( self.__report_prefix()), level=logging.WARN)
def _fetchFailed(self, failure): """Called when getProxyPage finished with a failure.""" self.report('Fetch failed, %.3f s' % (seconds() - self.checkStartTime)) self._resultDown(failure.getErrorMessage()) failure.trap(*self.catchList)
def _fetchSuccessful(self, result): """Called when getProxyPage is finished successfully.""" self.report('Fetch successful, %.3f s' % (seconds() - self.checkStartTime)) self._resultUp() return result
def runCommand(self): """Periodically called method that does a single uptime check.""" self.checkStartTime = seconds() self.runningProcess = self._spawnProcess(self, self.command, [self.command] + self.arguments, sessionLeader=True, timeout=(self.timeout or None)) self.runningProcessDeferred = defer.Deferred() return self.runningProcessDeferred
def timeout(self): # insert new delayed calls to make sure to include them in timeout value self._insertNewDelayedCalls() if not self._pendingTimedCalls: return None return max(0, self._pendingTimedCalls[0].time - seconds())
def setPlayerTimeout(self, game, packet): if packet.timeout > 0: packet.when = int(seconds()) player = game.getPlayer(packet.serial) player.getUserData()['timeout'] = ( packet.when, packet.timeout ) return True else: return False
def hold(self, delay, id = None): if delay > 0: delay = seconds() + delay if id == None: for (id, queue) in self._queues.iteritems(): queue.delay = delay else: self.getOrCreateQueue(id).delay = delay
def hold(self, delay, id=None): if delay > 0: delay = seconds() + delay if id == None: for (id, queue) in self._queues.iteritems(): queue.delay = delay else: self.getOrCreateQueue(id).delay = delay
def canHandlePacket(self, packet): if not self.factory.isAlwaysHandled(packet) and hasattr(packet, "game_id") and hasattr(packet, "serial"): delay = self.getPlayerDelay(self.factory.packet2game(packet), packet.serial) if delay <= seconds(): return ( True, 0 ) else: return ( False, delay ) else: return ( True, 0 )
def test07_tourneyRegister(self): """ Register to a tourney thru a proxy, using an authenticated session """ # # Create tourney # db = self.server_service.db cursor = db.cursor() cursor.execute( "INSERT INTO tourneys_schedule SET " "resthost_serial = %(rh_serial)d, " "active = 'y', " "start_time = %(stime)d, " "description_long = 'no description long', " "name = 'regularX', " "variant = 'holem', " "betting_structure = '1-2_20-200_no-limit', " "currency_serial = 1" % { 'rh_serial': self.server_service.resthost_serial, 'stime': seconds() + 36000 }) schedule_serial = cursor.lastrowid self.server_service.updateTourneysSchedule() cursor.execute( "SELECT serial FROM tourneys WHERE schedule_serial = %s", schedule_serial) tourney_serial = cursor.fetchone()[0] cursor.close() self.assertEqual(True, self.server_service.tourneys.has_key(tourney_serial)) # # Create user # info = self.server_service.auth(PACKET_LOGIN, ('user1', 'password1'), PacketPokerRoles.PLAY) serial = info[0][0] self.proxy_site.memcache.set('auth', str(serial)) # # Register tourney # d = client.getPage( "http://127.0.0.1:19480/POKER_REST?uid=uid&auth=auth", postdata= '{"type":"PacketPokerTourneyRegister","tourney_serial":%d,"serial":%d}' % (tourney_serial, serial)) def checkTable(result): packets = Packet.JSON.decode(result) self.assertEqual('PacketPokerTourneyRegister', packets[0]['type']) self.assertEqual(tourney_serial, packets[0]['tourney_serial']) return result d.addCallback(checkTable) return d
def touch(self, args): self.modified = int(runtime.seconds() * 1000) pollers = self.pollers self.pollers = [] args['modified'] = [self.modified] d = defer.DeferredList(pollers) for poller in pollers: poller.callback(deepcopy(args)) d.addCallback(lambda result: args) return d
def longPoll(self): if self.longPollFrequency > 0: delta = seconds() - self.sentTime in_line = len(self.queue.callbacks) if in_line <= 0 and delta > self.longPollFrequency: self.clearTimeout() d = self.sendPacket(PacketPokerLongPoll(),'{ "type": "PacketPokerLongPoll" }') d.addCallback(self.longPollCallback) else: self.scheduleLongPoll(delta)
def callLater(self, _seconds, _f, *args, **kw): """See twisted.internet.interfaces.IReactorTime.callLater. """ assert callable(_f), "%s is not callable" % _f assert sys.maxint >= _seconds >= 0, \ "%s is not greater than or equal to 0 seconds" % (_seconds,) tple = DelayedCall(seconds() + _seconds, _f, args, kw, self._cancelCallLater, self._moveCallLaterSooner) self._newTimedCalls.append(tple) return tple
def beginTurn(self): self._startLockCheck() self.cancelDealTimeout() if self.game.isEndOrNull(): self.historyReset() hand_serial = self.factory.getHandSerial() self.log.debug("Dealing hand %s/%d", self.game.name, hand_serial) self.game.setTime(seconds()) self.game.beginTurn(hand_serial) for player in self.game.playersAll(): player.getUserData()['ready'] = True
def getDynamicConfig(self, cb): # Requery the config if we haven't gotten an update in the # last hour. stale = ((self.cfg_lastUpdate is None) or (seconds() - self.cfg_lastUpdate >= 60*5)) stale = True if cb: self.cfg_cb = cb if stale or self.cfg_busy: self.main.showLoginStatus( local.dconfig_puller.startText(), counter=0) # If an update is already in progress, just wait for it. if self.cfg_busy: return # If we've done an update recently, then skip the query if (not stale) and cb: self.doCallback() return def success_cb(result): if not result: # This will trigger the err_cb below. raise ValueError("Empty Config Reply") try: self.handleConfig(result) self.cfg_lastUpdate = seconds() self.cfg_busy = False self.doCallback() except: # Don't want errors propagating up the chain. twisted.python.log.err() def err_cb(failure): try: if cb: self.main.showLoginStatus( "Query failed! Trying to proceed without it...") self.cfg_busy = False self.doCallback() except: # Don't want errors propagating up the chain. twisted.python.log.err() # Do Query self.cfg_busy = True d = local.dconfig_puller.query() d.addCallback(success_cb) d.addErrback(err_cb)
def _fetchFailed(self, failure): """Called when getProxyPage finished with a failure.""" # Don't act as if the check failed if we cancelled it if failure.check(defer.CancelledError): return None self.report('Fetch failed, %.3f s' % (seconds() - self.checkStartTime)) self._resultDown(failure.getErrorMessage()) failure.trap(*self.catchList)
def testProcessEndedProcessTerminated(self): """Assert that an unclean (non-zero) exit reports the monitor as down""" self.monitor.checkStartTime = runtime.seconds() self.monitor.runningProcessDeferred = twisted.internet.defer.Deferred() reason = failure.Failure(twisted.internet.error.ProcessTerminated("Process returned error")) with mock.patch.multiple(self.monitor, _resultUp=mock.DEFAULT, _resultDown=mock.DEFAULT) as mocks: self.monitor.processEnded(reason) mocks['_resultDown'].assert_called() mocks['_resultUp'].assert_not_called()
def pushPacket(self, packet): id = self._packet2id(packet) if id != None: packet.time__ = seconds() front = self._packet2front(packet) if front and id in self._queues: packet.nodelay__ = True self._queues[id].packets.insert(0, packet) else: packet.nodelay__ = False self.getOrCreateQueue(id).packets.append(packet) self.triggerTimer()
def userCreate(self, name, password): self.log.inform("creating user %s", name) cursor = self.db.cursor() cursor.execute( "INSERT INTO users (created, name, password) values (%s, %s, %s)", (seconds(), name, password) ) serial = cursor.lastrowid self.log.inform("create user with serial %s", serial) cursor.execute("INSERT INTO users_private (serial) values (%s)", (serial,)) cursor.close() return int(serial)