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

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()

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()

    def initialize(self,
                 io_loop=None,
                 keep_alive_milliseconds=37000,
                 # how often to check for unused sessions
                 check_unused_sessions_milliseconds=17000,
                 # how long unused sessions last
                 unused_session_lifetime_milliseconds=15000,
                 # how often to log stats
                 stats_log_frequency_milliseconds=15000,
                 **kw):

        if io_loop is None:
            io_loop = IOLoop.current()
        self._loop = io_loop

        for app_context in self._applications.values():
            app_context._loop = self._loop

        self._clients = set()
        self._executor = ProcessPoolExecutor(max_workers=4)
        self._loop.add_callback(self._start_async)
        self._stats_job = PeriodicCallback(self.log_stats,
                                           stats_log_frequency_milliseconds,
                                           io_loop=self._loop)
        self._unused_session_linger_milliseconds = unused_session_lifetime_milliseconds
        self._cleanup_job = PeriodicCallback(self.cleanup_sessions,
                                             check_unused_sessions_milliseconds,
                                             io_loop=self._loop)

        if keep_alive_milliseconds > 0:
            self._ping_job = PeriodicCallback(self.keep_alive, keep_alive_milliseconds, io_loop=self._loop)
        else:
            self._ping_job = None

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())

def run():
    parser = ArgumentParser()
    parser.add_argument("-f", "--fake", action="store_true", help="Use a fake connection for development")
    parser.add_argument("-i", "--id", default=socket.gethostname(), help="ID of this site")
    args = parser.parse_args()

    if args.fake:
        m = MissileLauncher(FakeMissileLauncherConnection())
    else:
        m = MissileLauncher(MissileLauncherConnection(0))

    config = {
        'launcher': m,
        'id': args.id
    }

    application = Application([
        (r"/position", PositionHandler, config),
        (r"/move/(-?[01])/(-?[01])", PositionHandler, config),
        (r"/move_to/([-0-9.]*)/([-0-9.]*)", MoveHandler, config),
        (r"/fire_at/([-0-9.]*)/([-0-9.]*)", FireHandler, config),
        (r"/calibrate", CalibrateHandler, config),
        (r"/", IndexHandler),
        (r"/static/(.*)", StaticFileHandler, {'path': 'static/'})
    ], debug=True)

    application.listen(7777)
    periodic = PeriodicCallback(m.timestep, 100)
    periodic.start()
    print('Site {} listening at http://{}:7777'.format(args.id, socket.gethostname()))
    IOLoop.instance().start()

 def start(self):
     periodic_task = PeriodicCallback(
         self.update,
         self.application.config.UPDATE_PERIOD * 1000,
         io_loop=self.main_loop
     )
     periodic_task.start()

    def start_task(self, task):

        self.log_reader = InstallLogReader(path=self.core.settings.tmp_logs_path, task_id=str(task.id))
        common_log = self.log_reader.common_working_log()
        self.logger.addHandler(TaskDbLogHandler(task))

        f_out = open(common_log, 'w')
        self.process = subprocess.Popen(
            (
                sys.executable,
                '-u',
                sys.argv[0],
                '--task-work={0}'.format(task.id),
            ),
            stderr=f_out,
            stdout=f_out
        )
        print("start child task with pid %i" % self.process.pid)
        task.parent_pid = os.getpid()
        task.pid = self.process.pid
        task.save()
        self.configs["task"] = task

        self.timer_check_logdir = PeriodicCallback(lambda: TornadoWorker.periodic_check_logdir(self), 700)
        self.timer_read_log = PeriodicCallback(lambda: TornadoWorker.periodic_read_logs(self), 300)

        self.timer_read_log.start()
        self.timer_check_logdir.start()

class WebSocketGame(WebSocketHandler):
    def open(self):
        self.game_data = {}
        self.initialize_game()
        self.write_message(self.game_data)

    def on_message(self, message):
        message = json.loads(message)
        if message["type"] == "login":
            self.game_name = message["name"]
            self.game_id = message["game_id"]
            self.loop_callback = PeriodicCallback(self.do_loop, 5000)
        else:
            self.handle_message(message)

    def on_close(self):
        self.loop_callback.stop()
        pass

    def update_status(self, status):
        if status not in ("S", "I", "U", "F"):  # Start, InProgress, Succesful, Fail
            return  # Let's try not to hit the status API with bad values.

        url = "http://localhost:8080/private_api/gametask/{}/{}/{}".format(self.game_name, self.game_id, status)
        request = HTTPRequest(url=url)
        http = AsyncHTTPClient()
        http.fetch(request, self.callback)

    def callback(self, response):
        # Catch any errors.
        print "Callback fired."
        print "HTTP Code: {}".format(response.code)

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"

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('config', help='config file')
    args = parser.parse_args()
    logger.warn('Reading config from {}'.format(args.config))

    config = {}
    with open(args.config, 'r') as infile:
        config = json.load(infile)

    if config == {}:
        sys.exit()

    serve_config = config.get('car_serve', {})
    logger.warn(serve_config)

    app = CarServer(config)

    try:
        logger.info('Opening HTTP server.')
        http_server = HTTPServer(app)
        http_server.listen(serve_config.get('port', 9001), address=serve_config.get('ip_address', '127.0.0.1'))
        update_ms = serve_config.get('update_ms', 100)
        logger.debug('Registering periodic callback. Every {} ms'.format(update_ms))
        i = PeriodicCallback(app.car_state.update_physical_state, update_ms)
        i.start()
        IOLoop.current().start()
    except (SystemExit, KeyboardInterrupt):
        pass

    logger.info('Stopping server.')
    http_server.stop()

    IOLoop.current().stop()
    sys.exit(0)

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,
    })

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))

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()

class cpustatus(tornado.websocket.WebSocketHandler):
	#on_message -> receive data
	#write_message -> send data
	
	#index.html
	def open(self):
		#self.i = readData()
		self.i = 0
		self.last = 0
		self.cpu = PeriodicCallback(self._send_cpu, 500) #
		self.cpu.start()

	def on_message(self, message):
		global MainMotorMax
		self.i = int(message)
		MainMotorMax = self.i
		print message

	def _send_cpu(self):
		#self.write_message(str(vmstat()[15]))
		#self.write_message(str(time.time()))
		#self.i = readData()
		if self.i != self.last:
			self.write_message(str(self.i))
			self.last = self.i
			print self.i
	#
	def on_close(self):
		self.cpu.stop()

class WSHandler(tornado.websocket.WebSocketHandler):
  # track clients:
  # simplest method is just to keep a list or dict of WSHandler instances:
  clients = []

  def open(self):
    self.clients.append(self)
    # print 'New connection was opened'
    # self.write_message("Welcome to my websocket!")

    # http://tornado.readthedocs.org/en/latest/ioloop.html
    # The callback is called every callback_time milliseconds.
    #  class tornado.ioloop.PeriodicCallback(callback, callback_time, io_loop=None)
    self.callback = PeriodicCallback(self.send_hello, 5000)
    self.callback.start()

  def send_hello(self):
    self.write_message('hello')


  def msg(self,message):
    self.write_message(message)
    threading.Timer(10, self.msg('in timer')).start()
    print 'in msg'+message

#  def on_message(self, message):
#    pass
  def on_message(self, message):
    print 'Incoming message:', message
    self.write_message("You said: " + message)

  def on_close(self):
    self.clients.remove(self)
    print 'Connection was closed...'

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...")

class WebSocket(tornado.websocket.WebSocketHandler):
    waiters = set()  # multi clients connect OK
    wdata = ""

    def open(self):
        print("open websocket connection")
        WebSocket.waiters.add(self)  # client add
        self.callback = PeriodicCallback(self._send_message, 30000)  # time out taisaku
        self.callback.start()

    def on_close(self):
        WebSocket.waiters.remove(self)  # client remove
        self.callback.stop()
        print("close websocket connection")

    def on_message(self, message):
        WebSocket.wdata = message
        WebSocket.send_updates(message)

    @classmethod
    def send_updates(cls, message):  # this method is singleton
        print(message + ":connection=" + str(len(cls.waiters)))
        for waiter in cls.waiters:
            try:
                waiter.write_message(message)
            except:
                print("Error sending message", exc_info=True)

    # TIME OUT BOUSHI CALL BACK 30Sec
    def _send_message(self):
        self.write_message("C:POLLING")

    def _run(self):
        assert self.message_handler, "you must specify the Reader's message_handler"

        logger.info('[%s] starting reader for %s/%s...', self.name, self.topic, self.channel)

        for addr in self.nsqd_tcp_addresses:
            address, port = addr.split(':')
            self.connect_to_nsqd(address, int(port))

        self.redist_periodic = PeriodicCallback(
            self._redistribute_rdy_state,
            5 * 1000,
            io_loop=self.io_loop,
        )
        self.redist_periodic.start()

        if not self.lookupd_http_addresses:
            return
        # trigger the first lookup query manually
        self.query_lookupd()

        self.query_periodic = PeriodicCallback(
            self.query_lookupd,
            self.lookupd_poll_interval * 1000,
            io_loop=self.io_loop,
        )

        # randomize the time we start this poll loop so that all
        # consumers don't query at exactly the same time
        delay = random.random() * self.lookupd_poll_interval * self.lookupd_poll_jitter
        self.io_loop.add_timeout(time.time() + delay, self.query_periodic.start)

class WSHandler(tornado.websocket.WebSocketHandler):
    def initialize(self):
        self.values = [[], []]

    def check_origin(self, origin):
        return True

    def open(self):
        # Send message periodic via socket upon a time interval
        self.initialize()
        self.callback = PeriodicCallback(self.send_values, timeInterval)
        self.callback.start()

    def send_values(self):
        MAX_POINTS = 30
        # Generates random values to send via websocket
        for val in self.values:
            if len(val) < MAX_POINTS:
                val.append(randint(1, 10))
            else:
                val.pop(0)
                val.append(randint(1, 10))
            # self.values1 = [randint(1,10) for i in range(100)]
        message = {"Channel0": self.values[0], "Channel1": self.values[1]}
        # self.write_message(message)
        message = {"DataInfo": [{"id": 40, "sname": "SOG"}]}
        self.write_message(message)

    def on_message(self, message):
        pass

    def on_close(self):
        self.callback.stop()