Python PeriodicCallback.start方法代码示例

# 需要导入模块: from tornado.ioloop import PeriodicCallback [as 别名]
# 或者: from tornado.ioloop.PeriodicCallback import start [as 别名]
 def add_periodic(self, callback, secs, name):
     if name not in self._timers:
         pcb = PeriodicCallback(callback, 1000*secs, io_loop=self.io_loop)
         self._timers[name] = (True, pcb)
         pcb.start()
     else:
         logging.warning("periodic timer with name %s already exists!", name)

# 需要导入模块: from tornado.ioloop import PeriodicCallback [as 别名]
# 或者: from tornado.ioloop.PeriodicCallback import start [as 别名]
class AsyncPopenFixed(seesaw.externalprocess.AsyncPopen):
    """
    Start the wait_callback after setting self.pipe, to prevent an infinite
    spew of "AttributeError: 'AsyncPopen' object has no attribute 'pipe'"
    """
    def run(self):
        self.ioloop = IOLoop.instance()
        (master_fd, slave_fd) = pty.openpty()

        # make stdout, stderr non-blocking
        fcntl.fcntl(master_fd, fcntl.F_SETFL,
            fcntl.fcntl(master_fd, fcntl.F_GETFL) | os.O_NONBLOCK)

        self.master_fd = master_fd
        self.master = os.fdopen(master_fd)

        # listen to stdout, stderr
        self.ioloop.add_handler(master_fd, self._handle_subprocess_stdout,
            self.ioloop.READ)

        slave = os.fdopen(slave_fd)
        self.kwargs["stdout"] = slave
        self.kwargs["stderr"] = slave
        self.kwargs["close_fds"] = True
        self.pipe = subprocess.Popen(*self.args, **self.kwargs)

        self.stdin = self.pipe.stdin

        # check for process exit
        self.wait_callback = PeriodicCallback(self._wait_for_end, 250)
        self.wait_callback.start()

# 需要导入模块: from tornado.ioloop import PeriodicCallback [as 别名]
# 或者: from tornado.ioloop.PeriodicCallback import start [as 别名]
def start_wanikani_updater():
    # Send first request
    request_update_wanikani()

    # Schedule a new update request every 30 seconds
    periodic_callback = PeriodicCallback(wrap_traceback(request_update_wanikani), 30 * 1000)  # milliseconds
    periodic_callback.start()

# 需要导入模块: from tornado.ioloop import PeriodicCallback [as 别名]
# 或者: from tornado.ioloop.PeriodicCallback import start [as 别名]
class Service(Scaffold):
    def __init__(self, interval=1):
        '''
        inteval is in seconds
        '''
        super(Service, self).__init__()
        self.interval = interval * 1000
        self.periodicalCb = None

    def stop(self):
        if self.periodicalCb:
            self.periodicalCb.stop()

    def run(self, *args, **kwargs):
        super(Service, self).run(*args, **kwargs)
        self.periodicalCb = PeriodicCallback(
            partial(super(Service, self).run, *args, **kwargs),
            self.interval, IOLoop.instance())
        self.periodicalCb.start()
        IOLoop.instance().start()

    def main(self):
        '''
        Subclass this method
        '''
        logging.error('Subclass main method... %s' % time.clock())

# 需要导入模块: from tornado.ioloop import PeriodicCallback [as 别名]
# 或者: from tornado.ioloop.PeriodicCallback import start [as 别名]
class EventedStatsCollector(StatsCollector):
    """
    Stats Collector which allows to subscribe to value changes.
    Update notifications are throttled: interval between updates is no shorter
    than ``accumulate_time``.

    It is assumed that stat keys are never deleted.
    """
    accumulate_time = 0.1  # value is in seconds

    def __init__(self, crawler):
        super(EventedStatsCollector, self).__init__(crawler)
        self.signals = SignalManager(self)
        self._changes = {}
        self._task = PeriodicCallback(self.emit_changes, self.accumulate_time*1000)
        self._task.start()

        # FIXME: this is ugly
        self.crawler = crawler  # used by ArachnadoCrawlerProcess

    def emit_changes(self):
        if self._changes:
            changes, self._changes = self._changes, {}
            self.signals.send_catch_log(stats_changed, changes=changes)

    def open_spider(self, spider):
        super(EventedStatsCollector, self).open_spider(spider)
        self._task.start()

    def close_spider(self, spider, reason):
        super(EventedStatsCollector, self).close_spider(spider, reason)
        self._task.stop()

# 需要导入模块: from tornado.ioloop import PeriodicCallback [as 别名]
# 或者: from tornado.ioloop.PeriodicCallback import start [as 别名]
class TempSocketHandler(websocket.WebSocketHandler):
    waiters = set()
    cache = []
    cache_size = 200
    actual_flag = ''

    def allow_draft76(self):
        return True

    def open(self):
        TempSocketHandler.waiters.add(self)
        self.callback = PeriodicCallback(self.send_flag, 1000)
        self.callback.start()

    def on_close(self):
        TempSocketHandler.waiters.remove(self)

    @classmethod
    def update_cache(cls, chat):
        cls.cache.append(chat)
        if len(cls.cache) > cls.cache_size:
            cls.cache = cls.cache[-cls.cache_size:]

    def send_flag(self):
        if len(self.waiters) > 0:
            logging.info("sending message to %d waiters", len(self.waiters))
            data = '{"time":"'+str(int(time.time()))+'","data":"'+str(random.randrange(0, 100))+'"}'
            self.write_message(data)
        else:
            logging.info("No one is waiting...")

# 需要导入模块: from tornado.ioloop import PeriodicCallback [as 别名]
# 或者: from tornado.ioloop.PeriodicCallback import start [as 别名]
 def start(self):
     periodic_task = PeriodicCallback(
         self.update,
         self.application.config.UPDATE_PERIOD * 1000,
         io_loop=self.main_loop
     )
     periodic_task.start()

# 需要导入模块: from tornado.ioloop import PeriodicCallback [as 别名]
# 或者: from tornado.ioloop.PeriodicCallback import start [as 别名]
def broadcast_match_info():
    global pcb

    if pcb is None:
        pcb = PeriodicCallback(broadcast_match_info, 500)
        pcb.start()


    matches = MatchModel.objects.all()
    match_status = {}
    for match in matches:
        fixture = FixtureModel.objects.get(id=match.match_id)
        r = ResultModel.objects.get(id=match.match_id)
        if(r.result != 'None'):
            match_status['color'+str(match.match_id)] = 'info'
            continue
        dd = fixture.match_day - timezone.now() 
        dd_str = None
        if(timezone.now() > fixture.match_day):
            dd_str = "Locked"
            match_status['color'+str(match.match_id)] = 'danger'
        else: 
            dd_str = "%sd:%sh:%sm:%ss" %(str(dd.days),str((dd.seconds//3600)%24),str((dd.seconds%3600)//60), str((dd.seconds%3600)%60),)
            match_status['color'+str(match.match_id)] = 'success'
        match_status['time_left'+str(match.match_id)] = dd_str
        match_status['storedbet'+str(match.id)] = "%s %s" %(match.betting_side, match.betting_points,)
        match_status['odds'+str(match.match_id)] = "%s:%s"  %(fixture.home_odds, fixture.away_odds,)
    publish_data('matchinfo', {
        'match_status': match_status,
    })

# 需要导入模块: from tornado.ioloop import PeriodicCallback [as 别名]
# 或者: from tornado.ioloop.PeriodicCallback import start [as 别名]
class WebSocketHandler(websocket.WebSocketHandler):
    def initialize(self, queue):
        self.clients = dict()
        self.queue = queue
        self.callback = PeriodicCallback(self.message_clients, 120)
        self.callback.start()

    def open(self, *args):
        self.id = self.get_argument("id")
        self.stream.set_nodelay(True)
        self.clients[self.id] = {"id": self.id, "object": self}

    def on_message(self, message):
        """
        when we receive some message we want some message handler..
        for this example i will just print message to console
        """
        print "Client %s received a message : %s" % (self.id, message)

    def on_close(self):
        if self.id in self.clients:
            del self.clients[self.id]
            print "Removed client " + self.id

    def message_clients(self):
        message = self.queue.get()
        for client in self.clients:
            try:
                self.write_message(message)
            except:
                print "Message could not be written"

# 需要导入模块: from tornado.ioloop import PeriodicCallback [as 别名]
# 或者: from tornado.ioloop.PeriodicCallback import start [as 别名]
class WSHandler(tornado.websocket.WebSocketHandler):
	def check_origin(self, origin):
		return True
    
	def open(self):
		with q_live.mutex:
			q_live.queue.clear()
		self.callback = PeriodicCallback(self.send_werte, 1)
		self.callback.start()
		print ('Connection open')	
	def send_werte(self):
		if not q_live.empty():
			signals, values = q_live.get()
			senden = dict(zip(signals,values))
			print(senden)
			json_send = json.dumps(senden)
			self.write_message(json_send)
			print(q_live.qsize())
			if q_live.qsize() >15:
				with q_live.mutex:
					q_live.queue.clear()
	def on_message(self, empf):
		  print('Daten recievied: ')

	def on_close(self):
		print('Connection closed!')
		self.callback.stop()

# 需要导入模块: from tornado.ioloop import PeriodicCallback [as 别名]
# 或者: from tornado.ioloop.PeriodicCallback import start [as 别名]
class ThroughputTracker(object):

    def __init__(self, logger, loop, num_samples=3):
        self.logger = logger
        self.loop = loop
        # callback_time is in milliseconds
        self.throughput_pc = PeriodicCallback(self.onThroughput,
                                              30 * 1000,
                                              self.loop)
        self.throughput_pc.start()
        self.samples = deque(maxlen=num_samples)
        self.samples.appendleft(ThroughputSample(timestamp=datetime.utcnow(),
                                                 num_emitted=0))
        self.num_emitted = 0

    def onThroughput(self):
        # Throughput measurements
        now = datetime.utcnow()
        current = ThroughputSample(timestamp=now, num_emitted=self.num_emitted)
        deltas = [
            current.timestamp - sample.timestamp
            for sample in self.samples
        ]
        samples = [
            '%s|%0.1f' % (
                deltas[i],
                ((current.num_emitted-sample.num_emitted) /
                 deltas[i].total_seconds()),
            )
            for i, sample in enumerate(self.samples)
        ]
        self.samples.appendleft(current)
        self.logger.info('Throughput samples: %s', ', '.join(samples))

# 需要导入模块: from tornado.ioloop import PeriodicCallback [as 别名]
# 或者: from tornado.ioloop.PeriodicCallback import start [as 别名]
def start_game():
    ''' Main entry point for the application '''
    cache_actions()
    sockets = netutil.bind_sockets(8888)
    #if process.task_id() == None:
    #    tornado.process.fork_processes(-1, max_restarts = 10)
    server = HTTPServer(application)
    server.add_sockets(sockets)
    io_loop = IOLoop.instance()
    session_manager = SessionManager.Instance()
    if process.task_id() == None:
        scoring = PeriodicCallback(scoring_round, application.settings['ticks'], io_loop = io_loop)
        session_clean_up = PeriodicCallback(session_manager.clean_up, application.settings['clean_up_timeout'], io_loop = io_loop)
        scoring.start()
        session_clean_up.start()
    try:
        for count in range(3, 0, -1):
            logging.info("The game will begin in ... %d" % (count,))
            sleep(1)
        logging.info("Good hunting!")
        io_loop.start()
    except KeyboardInterrupt:
        if process.task_id() == 0:
            print '\r[!] Shutdown Everything!'
            session_clean_up.stop()
            io_loop.stop()

# 需要导入模块: from tornado.ioloop import PeriodicCallback [as 别名]
# 或者: from tornado.ioloop.PeriodicCallback import start [as 别名]
def broadcast_sys_info():
    global upCount, downCount, leftCount, rightCount
    global pcb, ser
    if pcb is None:
        pcb = PeriodicCallback(broadcast_sys_info, 100)
        pcb.start()

    valueRead = serialArduino.readline()
    choiceSearch = re.search("UP|DOWN|LEFT|RIGHT", str(valueRead))
    try:
        left_sent = 0
        right_sent = 0
        up_sent = 0
        down_sent = 0
        choice = choiceSearch.group(0)
        print(choice)
        if choice == "UP":
            up_sent += 1
            upCount += 1
        elif choice == "DOWN":
            down_sent += 1
            downCount += 1
        elif choice == "LEFT":
            left_sent += 1
            leftCount += 1
        elif choice == "RIGHT":
            right_sent += 1
            rightCount += 1
        publish_data("sysinfo", {"left_t": left_sent, "right_t": right_sent, "top": up_sent, "down": down_sent})
    except AttributeError:
        pass

# 需要导入模块: from tornado.ioloop import PeriodicCallback [as 别名]
# 或者: from tornado.ioloop.PeriodicCallback import start [as 别名]
class SendWebSocket(tornado.websocket.WebSocketHandler):
    #on_message -> receive data
    #write_message -> send data
    def __init__(self, *args, **keys):
        self.i = 0
        super(SendWebSocket, self).__init__(*args, **keys)

    def open(self):
        self.callback = PeriodicCallback(self._send_message, 1)
        self.callback.start()
        print "WebSocket opend"

    def on_message(self, message):
        print message


    def _send_message(self):
        self.i += 1
        self.write_message(str(self.i))
        if self.i % 20 == 0:
            self.write_message("\n")

    def on_close(self):
        self.callback.stop()
        print "WebSocket closed"

# 需要导入模块: from tornado.ioloop import PeriodicCallback [as 别名]
# 或者: from tornado.ioloop.PeriodicCallback import start [as 别名]
def broadcast_players(g_id):
    global pcb2
    global cur_g_id
    data_dict = {}

    if pcb2 is None:
        cur_g_id = g_id
        pcb2 = PeriodicCallback(lambda: broadcast_players(g_id), 4000)
        pcb2.start()
    elif cur_g_id != g_id:
        cur_g_id = g_id
        pcb2.stop()
        pcb2 = PeriodicCallback(lambda: broadcast_players(g_id), 4000)
        pcb2.start()

    g_list = ww_redis_db.keys(g_id+"*")
    for v in g_list:
        v = v.decode("utf-8")

        if len(g_list) > 0:
            # find game with least spaces
            for g_key in g_list:
                game = ww_redis_db.hgetall(g_key)
                game = {k.decode('utf8'): v.decode('utf8') for k, v in game.items()}	#convert from byte array to string dict

                players = game['players'].split("|")		# obtain players in current game in the form of uuid

                data_dict[g_key.decode("utf-8")] = str(len(players))

    data_dict["channel"] = "player_list"

    publish_data("player_list:"+g_id, data_dict)

    return data_dict