def _send_servo_commands(self):
        servo_started_up = False

        while True:
            if ((not servo_started_up)
                and self.mech_driver
                and self.mech_driver.servo):
                servo_started_up = True
                # Reset all servos on startup, as they may have had an pending
                # error due to power glitch or something similar.
                self.logger.info('Rebooting servos on startup')
                yield From(self.mech_driver.servo.reboot())

            if not self.servo_send_now.is_set():
                # Make sure we wake up periodically
                asyncio.get_event_loop().call_later(
                    SERVO_SEND_INTERVAL, self.servo_send_now.set)
            yield From(self.servo_send_now.wait())
            self.servo_send_now.clear()

            new_pkt = self.net_packet
            old_pkt = self.servo_packet
            if new_pkt is not None:
                yield From(self._send_servo_commands_once(
                        new_pkt, old_pkt))
            self.servo_packet = new_pkt

            # send any status updates
            self.status_send_now.set()

	def __init__(self, cameras=[], port=9004, users_file="users.json", recognition_db="recognition.db"):

		Server.__init__(self, port=port, usessl=False)

		self.recognition_db = recognition_db

		self.last_user_uuid = ""
		self.last_len_persons_detected = -1
		self.last_len_users = -1

		self.camera_clients = []
		self.recognizer = Recognizer(users_file)

		self.cameras = cameras
		self.start()

		self.method_handlers = {}
		self.method_handlers["list_users"] = self.list_users
		self.method_handlers["select_camera"] = self.select_camera
		self.method_handlers["list_users_with_level"] = self.list_users_with_level
		self.method_handlers["add_association"] = self.add_association

		self.users_recognized = []

		asyncio.get_event_loop().create_task(self.poll())

	def __init__(self, name, processes=1, maxQueueSize=100, args=None):
		try:
			self.pool = []
			self.resultQueue = DeQueue(maxQueueSize)
			self.dataQueue = DeQueue(maxQueueSize)
			self.debugQueue = Queue()
			self.name = name
			self.variables = {}

			print ("processes for {} = {}".format(name, processes))

			for i in range(processes):
				if args:
					p = Process(target=self.process, args=args)
				else:
					p = Process(target=self.process)
				self.pool.append(p)
				p.start()

			asyncio.get_event_loop().create_task(self.poll())

		except:
			exc_type, exc_value, exc_traceback = sys.exc_info()
			traceback.print_tb(exc_traceback, limit=1, file=sys.stdout)
			traceback.print_exception(exc_type, exc_value, exc_traceback,
            	          limit=2, file=sys.stdout)

	def __init__(self, pollRate = MINS(10), port=9001, sslcert = "server.crt", sslkey= "server.key", privateKeyFile = 'dhserver.key', clientsFile = "clients.json"):
		Server.__init__(self, True, port, sslcert, sslkey, privateKeyFile = privateKeyFile, clientsFile = clientsFile)
		self.pollRate = pollRate
		self.port = port

		self.numclients = len(self.clients)
		
		asyncio.get_event_loop().create_task(self.poll())

 def test_send_error(self):
     """An error in sending must be reported through the future."""
     # Create a stream with a packet size that is bigger than the likely
     # MTU. It should cause an error.
     stream = UdpStream(
         spead2.ThreadPool(), "localhost", 8888,
         spead2.send.StreamConfig(max_packet_size=100000), buffer_size=0)
     future = stream.async_send_heap(self.heap)
     trollius.get_event_loop().run_until_complete(self._test_send_error(future))

 def test_async_flush_fail(self):
     """Test async_flush in the case that the last heap sent failed.
     This is arranged by filling up the queue slots first.
     """
     for i in range(5):
         trollius.async(self.stream.async_send_heap(self.heap))
     # The above only queues up the async sends on the event loop. The rest of the
     # test needs to be run from inside the event loop
     trollius.get_event_loop().run_until_complete(self._test_async_flush())

 def session_made(self, conn):
     """
     called when we established a session to the router
     we can look up names/b32 but can't send messages to others yet
     :param conn: our i2cp connection that we are using
     """
     self.conn = conn
     self._log.info('session made we are {}'.format(conn.dest))
     asyncio.get_event_loop().call_later(self._delay, self._send)

def main():
    logging.basicConfig(level=logging.WARN, stream=sys.stdout)

    parser = optparse.OptionParser(description=__doc__)

    MechDriver.add_options(parser)

    options, args = parser.parse_args()

    task = Task(start(options))
    asyncio.get_event_loop().run_until_complete(task)

	def onJoin(self, details):
		print("Session Joined.")
		#Setting variables
		self.lastServoValue = 417 #Assumes it starts in the middle
		self.servoMin = 315  # Min pulse length out of 4096
		self.servoMax = 520  # Max pulse length out of 4096
		self.servoMiddle = 417 # middle servo value
		self.servoChannel = 3        
		print "What is happening????"
		self.motorMiddle = 1500
		self.motorChannel = 2
		self.subscribe(self.joyMonitor, 'aero.near.joystream')
		print "joystream ok"
		#subscribe to methods to prevent register conflicts
		self.subscribe(self.honkCommand, 'aero.near.honkHorn')
		print "honk ok"
		self.subscribe(self.emergencyStop, 'aero.near.emergStop')
		print "emergstop ok"
		self.subscribe(self.manualOverride, 'aero.near.override')
		print "About to make the loop"
		self.gps_data = {'latitude': 0,'longitude': 0,'heading': 0,'speed': 0}
		
 		self.loop = asyncio.get_event_loop()
#		self.loop.stop()
#		future = asyncio.Future()
#		print "the future exists"
#		asyncio.async(self.gpsUpdate())
#		self.loop.run_until_complete(future)
#		self.loop = asyncio.new_event_loop()
# 		tasks = [
# 			asyncio.async(self.honk()),
# #			asyncio.async(self.lidarRead())]
# #			asyncio.async(self.gpsUpdate())]
# #			asyncio.async(self.internet_on())]
# 		print tasks
# 		swag.system('cls' if swag.name == 'nt' else 'clear')
# 		try:
		self.loop = asyncio.get_event_loop()
		tasks = [
			asyncio.async(self.netDisconnect())]
		print tasks
		try:
			done, pending = yield self.loop.run_until_complete(asyncio.wait(tasks))
		except Exception as e:
			print e
		print tasks
		#print "running"
		self.loop.close()
# 			done, pending = yield self.loop.run_until_complete(asyncio.wait(tasks))
# 		except Exception as e:
			# print e
		# print tasks
		print "running"

    def _connect_dual_stack(self, primary_address, secondary_address):
        '''Connect using happy eyeballs.'''
        self._primary_connection = self._connection_factory(primary_address)
        self._secondary_connection = self._connection_factory(secondary_address)

        @trollius.coroutine
        def connect_primary():
            yield From(self._primary_connection.connect())
            raise Return(self._primary_connection)

        @trollius.coroutine
        def connect_secondary():
            yield From(self._secondary_connection.connect())
            raise Return(self._secondary_connection)

        primary_fut = connect_primary()
        secondary_fut = connect_secondary()

        failed = False

        for fut in trollius.as_completed((primary_fut, secondary_fut)):
            if not self._active_connection:
                try:
                    self._active_connection = yield From(fut)
                except NetworkError:
                    if not failed:
                        _logger.debug('Original dual stack exception', exc_info=True)
                        failed = True
                    else:
                        raise
                else:
                    _logger.debug('Got first of dual stack.')

            else:
                @trollius.coroutine
                def cleanup():
                    try:
                        conn = yield From(fut)
                    except NetworkError:
                        pass
                    else:
                        conn.close()
                    _logger.debug('Closed abandoned connection.')

                trollius.get_event_loop().create_task(cleanup())

        if self._active_connection.address == secondary_address:
            preferred_addr = secondary_address
        else:
            preferred_addr = primary_address

        self._happy_eyeballs_table.set_preferred(preferred_addr, primary_address, secondary_address)

    def _start_tls(self):
        '''Start SSL protocol on the socket.'''
        socket_ = self._writer.get_extra_info('socket')

        try:
            trollius.get_event_loop().remove_reader(socket_.fileno())
        except ValueError as error:
            raise trollius.ConnectionAbortedError() from error

        self._writer.write(b'HTTP/1.1 200 Connection established\r\n\r\n')
        yield From(self._writer.drain())

        try:
            trollius.get_event_loop().remove_writer(socket_.fileno())
        except ValueError as error:
            raise trollius.ConnectionAbortedError() from error

        ssl_socket = ssl.wrap_socket(
            socket_, server_side=True,
            certfile=self._cert_filename,
            keyfile=self._key_filename,
            do_handshake_on_connect=False
        )

        # FIXME: this isn't how to START TLS
        for dummy in range(1200):
            try:
                ssl_socket.do_handshake()
                break
            except ssl.SSLError as error:
                if error.errno in (ssl.SSL_ERROR_WANT_READ, ssl.SSL_ERROR_WANT_WRITE):
                    _logger.debug('Do handshake %s', error)
                    yield From(trollius.sleep(0.05))
                else:
                    raise
        else:
            _logger.error(_('Unable to handshake.'))
            ssl_socket.close()
            self._reject_request('Could not start TLS')
            raise trollius.ConnectionAbortedError('Could not start TLS')

        loop = trollius.get_event_loop()
        reader = trollius.StreamReader(loop=loop)
        protocol = trollius.StreamReaderProtocol(reader, loop=loop)
        transport, dummy = yield From(loop.create_connection(
            lambda: protocol, sock=ssl_socket))
        writer = trollius.StreamWriter(transport, protocol, reader, loop)

        self._reader = reader
        self._writer = writer

    def __init__(self, config_file):
        super(Tourbillon, self).__init__()

        self._aio_run_event = asyncio.Event()
        self._thr_run_event = threading.Event()
        self._loop = asyncio.get_event_loop()
        self._tasks = []
        self._pluginconfig = {}

        with open(config_file, 'r') as f:
            self._config = json.load(f)

        formatter = logging.Formatter(fmt=self._config['log_format'])
        handler = logging.handlers.WatchedFileHandler(
            self._config['log_file'])
        handler.setFormatter(formatter)
        handler.setLevel(getattr(logging, self._config['log_level']))
        logging.getLogger().addHandler(handler)
        logging.getLogger().setLevel(
            getattr(logging, self._config['log_level']))

        logger.info('Use config file: %s', config_file)

        self._load_plugins_config(os.path.abspath(
                                  os.path.dirname(config_file)))

        self._influxdb = InfluxDBClient(**self._config['database'])
        self._databases = [i['name']
                           for i in self._influxdb.get_list_database()]
        print(self._databases)

    def test_queue_overload(self):

        http = HTTPConnectionPool('httpbin.org', maxsize=3, block=True, timeout=3)

        testLoop = asyncio.get_event_loop()
        testLoop.set_debug(True)
        global test_queue_overload_count
        test_queue_overload_count = 0

        @asyncio.coroutine
        def get_page():
            global test_queue_overload_count
            try:
                resp = yield From(http.request('GET', '/delay/1', pool_timeout=3))
                pg = yield From(resp.data)
                self.assertTrue(b'Connection' in pg, pg)
            except EmptyPoolError:
                pass
            except Exception as e:
                raise
            else:
                test_queue_overload_count += 1

        pageGetters = [get_page(), get_page(), get_page(), get_page(), get_page()]
        testLoop.run_until_complete(asyncio.wait(pageGetters, return_when=asyncio.ALL_COMPLETED))
        self.assertGreater(test_queue_overload_count, 4, 'not all page_getters ran')

 def __init__(self, log, max_pool=10, max_tasks=5):
     self.log = log
     self.max_pool = max_pool  # Overall limit.
     self.max_tasks = max_tasks  # Per-key limit.
     self.loop = asyncio.get_event_loop()
     self.connections = {}  # {(host, port, ssl): [Connection, ...], ...}
     self.queue = []  # [Connection, ...]

def main():
    global SERVER

    try:
        loop = trollius.get_event_loop()
        coro = trollius.start_server(
            handle_client,
            host=None,
            port=pagure.APP.config['EVENTSOURCE_PORT'],
            loop=loop)
        SERVER = loop.run_until_complete(coro)
        log.info('Serving server at {}'.format(SERVER.sockets[0].getsockname()))
        if pagure.APP.config.get('EV_STATS_PORT'):
            stats_coro = trollius.start_server(
                stats,
                host=None,
                port=pagure.APP.config.get('EV_STATS_PORT'),
                loop=loop)
            stats_server = loop.run_until_complete(stats_coro)
            log.info('Serving stats  at {}'.format(
                stats_server.sockets[0].getsockname()))
        loop.run_forever()
    except KeyboardInterrupt:
        pass
    except trollius.ConnectionResetError:
        pass

    # Close the server
    SERVER.close()
    if pagure.APP.config.get('EV_STATS_PORT'):
        stats_server.close()
    log.info("End Connection")
    loop.run_until_complete(server.wait_closed())
    loop.close()
    log.info("End")

def connect_read_pipe(file):
    loop = asyncio.get_event_loop()
    stream_reader = asyncio.StreamReader(loop=loop)
    def factory():
        return asyncio.StreamReaderProtocol(stream_reader)
    transport, _ = yield From(loop.connect_read_pipe(factory, file))
    raise Return(stream_reader, transport)

 def __init__(self, *args, **kwargs):
     self._loop = kwargs.pop('loop', None)
     super(Wrapped, self).__init__(*args, **kwargs)
     if self._loop is None:
         self._loop = trollius.get_event_loop()
     self._active = 0
     self._last_queued_future = None

def ThriftAsyncServerFactory(
    processor, interface=None, port=0, loop=None, nthreads=None, sock=None,
    backlog=100
):
    if loop is None:
        loop = asyncio.get_event_loop()

    if not isinstance(processor, TProcessor):
        try:
            processor = processor._processor_type(processor, loop=loop)
        except AttributeError:
            raise TypeError(
                "Unsupported processor type: {}".format(type(processor)),
            )

    if nthreads:
        from concurrent.futures import ThreadPoolExecutor
        loop.set_default_executor(
            ThreadPoolExecutor(max_workers=nthreads),
        )
    event_handler = TServerEventHandler()
    pfactory = ThriftServerProtocolFactory(processor, event_handler, loop)
    server = yield From(loop.create_server(
        pfactory,
        interface,
        port,
        sock=sock,
        backlog=backlog,
    ))

    if server.sockets:
        for socket in server.sockets:
            event_handler.preServe(socket.getsockname())

    raise Return(server)

def analyze_body(sdf, address=("127.0.0.1", 11346)):
    """
    Single body analyzer. Opens a new connection, analyzes the
    body, and returns the result. If you already have a manager
    running doing other things, create an instance of `BodyAnalyzer`
    instead.

    :param sdf: SDF object consisting of BodyPart
                instances.
    :type sdf: SDF
    :param address: Tuple of the hostname and port where the analyzer resides. Note
                    that the default is one up from the default Gazebo port,
                    since it is meant to be used with the `run-analyzer.sh` tool.
    :type address: (str, int)
    :return:
    :rtype: (bool, (float, float, float))
    """
    response_obj = [None]

    @trollius.coroutine
    def internal_analyze():
        analyzer = yield From(BodyAnalyzer.create(address))
        response_obj[0] = yield From(analyzer.analyze_sdf(sdf))

    loop = trollius.get_event_loop()
    loop.run_until_complete(internal_analyze())
    return response_obj[0]

    def produce_record(self, stream, key, data):
        record = Record(key, data, stream)
        stream = self.runner.streams[stream]

        loop = trollius.get_event_loop()
        for subscriber in stream.subscribers:
            loop.call_soon(subscriber.process_record, self, record)