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 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 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 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 _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 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 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 __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 _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 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 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 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 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 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 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