def __init__(self):
        """ Initialize system state and components """
        try:
            # Load state
            self.startup() # TODO make an init without cloned state an option
            # Create main event loop
            self.loop = asyncio.get_event_loop()
            # Create BPCon instance
            self.bpcon = BPConProtocol(self.conf, self.state)
            self.state.groups['G1'] = self.bpcon.peers # connect BPCon to Congregate instance
            self.paxos_server = websockets.serve(self.bpcon.main_loop, self.conf['ip_addr'], self.conf['port'], ssl=self.conf['ssl'])
            self.loop.run_until_complete(self.paxos_server)
            log.info("Started BPCon on port {}".format(self.conf['port']))

            # Create Congregate instance
            self.c = CongregateProtocol(self.loop, self.conf, self.bpcon)       
            self.congregate_server = websockets.serve(self.c.main_loop, self.conf['ip_addr'], self.conf['port']+1, ssl=self.conf['ssl'])
            self.loop.run_until_complete(self.congregate_server)
            log.info("Started Congregate on port {}".format(self.conf['port']+1))

            # Create API server
            self.web_server = websockets.serve(self.mainloop, self.conf['ip_addr'], self.conf['port']+2) 
            self.loop.run_until_complete(self.web_server)
            log.info("Started Web Server on port {}".format(self.conf['port']+2))

            # Add self to local group
            log.debug("adding self to local group")
            self.join_request()
            

            # Testing 
            if self.conf['is_client']:
                #self.c.reconfig()
                log.debug("is client. making test requests")
                for x in range(1):
                    request = "P,{},hello{}".format(x,x)
                    self.local_request("P,test,value")
                    self.local_request("P,test1,value1")
                    self.local_request("P,test2,value2")
                    self.local_request("P,test,value3")
                    self.local_request("D,test2,")
                    self.local_request(request)

                log.debug("requests complete")     
            else:
                #self.c.request_split()
                self.local_request("S,,")

                #self.c.request_merge("G2")
                self.group_request("M", "G2")

        except Exception as e:
            log.info(e)

def startup(callback):
    controlws = ControlWS()
    controlws.callback = callback
    start_server = websockets.serve(controlws.handler, 'tribot.shack', 1337)

    asyncio.get_event_loop().run_until_complete(start_server)
    asyncio.get_event_loop().run_forever()

  def listen(self, port, host):
    logger.info("Server listening on %s:%s.", host, port)
    self.store.lock()

    green.await_coro(
        websockets.serve(green.coroutine(self.accept),
                         host, port))

def servewebsocketrunforever(portnumber):
    print("serving", ipaddress, portnumber)
    start_server = websockets.serve(handler, ipaddress, portnumber)
    mainasyncloop.run_until_complete(start_server)
    receivertask = asyncio.async(receiverall())
    producertask = asyncio.async(producer())
    mainasyncloop.run_forever()

 def __init__(self, host, port):
     self.loop = asyncio.new_event_loop()
     asyncio.set_event_loop(self.loop)
     self.server = websockets.serve(self.receiver, host, port, loop=self.loop)
     self.host = host
     self.port = port
     WebSocket.loop = self.loop

def testWebsocketTransport():
	@asyncio.coroutine
	def serverRoutine(websocket, path):
		print("new connection")
		receiver = TransportGateway(enc, WebsocketTransport(websocket), debugMode = True)
		receiver.exposeObjectImplementation(TestImplementation)
		yield from asyncio.sleep(0.5)
		a = yield from  (receiver << Test.requestNew(1))
		print(a)
		b = yield from a.echo("asd")
		print(b)
		b = yield from a.echo("asd")
		print(b)
		b = yield from a.echo("asd")
		print(b)

		#yield from receiver.serverMode()
		print("connection closed")


	@asyncio.coroutine
	def clientRoutine():
		websocket = yield from websockets.connect('ws://localhost:8765/')
		return TransportGateway(enc, WebsocketTransport(websocket), debugMode = True)
		

	start_server = websockets.serve(serverRoutine, 'localhost', 8765)
	asyncio.get_event_loop().run_until_complete(start_server)
	asyncio.get_event_loop().run_forever()

def main():
	"""
	Setup and run all subroutines.
	"""
	global socks, queue, authed, sessions, queuehash, upkeepThread, pluginUpkeeps

	pluginList = plugins.getPlugins()
	pluginUpkeeps = list(filter(lambda module: hasattr(module, "upkeep"), pluginList))
	comm.buildCommands(pluginList)
	laserqueue.buildLists(pluginList)

	# Load the queue if -b is used
	if args.backup:
		if os.path.exists("cache.json"):
			queue = laserqueue.Queue.load(open("cache.json"))
		else:
			json.dump({}, open("cache.json", "w"))

	color_print("Serving WebSockets on 0.0.0.0 port {port} ...", port=config["port"])

	# Create the upkeep thread
	upkeepThread = threading.Thread(target=upkeep)
	upkeepThread.daemon = True
	upkeepThread.start()

	# Create the server event loop
	start_server = websockets.serve(server, "0.0.0.0", config['port'])
	loop = asyncio.get_event_loop()
	try:
		loop.run_until_complete(start_server)
		loop.run_forever()
	except KeyboardInterrupt:
		quit(0)

async def start_websockets(websocket_handlers):
    import websockets
    futures = []
    for handler, host, port in websocket_handlers:
        ws_future = websockets.serve(handler, host, port)
        futures.append(ws_future)
    await asyncio.gather(*futures)

 def make_server(self, port, listen='0.0.0.0'):
     context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
     context.load_cert_chain('/etc/ssl/certs/ssl-cert-snakeoil.pem',
                             '/etc/ssl/private/ssl-cert-snakeoil.key')
     self.log.info('UVC management server started on port %i' % port)
     return websockets.serve(self.handle_camera,
                             listen, port, ssl=context)

    def __run_loop(self):
        # Set event loop
        if self.background:
            logging.info("Running in background")
            asyncio.set_event_loop(self.loop)

        # Create the loop server
        self.server = self.loop.run_until_complete(websockets.serve(self.handler, self.address, self.port))

        try:
            logging.info("Starting server")
            self.loop.run_forever()

        except KeyboardInterrupt:
            logging.info("Keyboard Interrupt received.")

        finally:
            # Tell any clients that we're closing
            self.server.close()
            self.loop.run_until_complete(asyncio.sleep(0.1))

            # Gather any remaining tasks so we can cancel them
            asyncio.gather(*asyncio.Task.all_tasks()).cancel()
            self.loop.stop()

            logging.info("Cancelling pending tasks...")
            self.loop.run_forever()

            logging.info("Stopping Server...")
            self.loop.close()

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('-c', '--config', default=default.GEOFFREY_RC_FILE)
    parser.add_argument('path', nargs='+')
    args = parser.parse_args()
    config = Config(args.config, create=True)

    main = config['geoffrey']
    host = main.get('host', default.HOST)
    websocket_port = main.get('websocket_port', default.WEBSOCKET_PORT)
    webserver_port = main.get('webserver_port', default.WEBSERVER_PORT)

    loop = asyncio.get_event_loop()

    em = EventManager()
    plugins = get_plugins(config, output_queue)
    for subscriptions in plugins.call('get_subscriptions'):
        em.add_subscriptions(subscriptions)

    mask = em.get_mask()

    asyncio.Task(websockets.serve(websocket_server, host, websocket_port))
    asyncio.Task(watch_files(args.path, mask=mask))
    asyncio.Task(em.consume_events(event_queue, output_queue))
    webapp.run()
    loop.run_forever()

    def start(self):
        self._debug("Starting server")
        # scopeless version of self
        this = self
        # A handler function that represents the event loop
        @asyncio.coroutine
        def handler(websocket, path):
            self._debug("Got client: " + str(websocket.remote_address))
            while True:
                # on each new loop
                tasks = []
                for task in this.handler_threads:
                    tasks.append(asyncio.async(
                        task(websocket)
                    ))
                # Blocking method that takes a list of thread ids
                # and yields a tuple when any one is finished. The first item
                # is a list of done thread ids, and the other is a list of
                # thread ids that have not finished yet
                done, pending = yield from asyncio.wait(
                    tasks,
                    return_when=asyncio.FIRST_COMPLETED
                )
        # start the websocket server
        ws_server = websockets.serve(handler, self.host, self.port)

        asyncio.get_event_loop().run_until_complete(ws_server)
        asyncio.get_event_loop().run_forever()

def run_pubsub_server(host, port):
    logger.info("Starting pubsub server on %s:%d", host, port)

    start_server = websockets.serve(client_handler, host, port, klass=get_protocol_handler_klass())

    asyncio.get_event_loop().run_until_complete(start_server)
    asyncio.get_event_loop().run_forever()

def lance_broadcast():
    start_server = websockets.serve(handler_cast, get_lan_ip(), 8003)
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)
    asyncio.get_event_loop().run_until_complete(start_server)
    print("Websocket connection launched on port 8003")
    asyncio.get_event_loop().run_forever()

def main():
    parser = argparse.ArgumentParser(description='A simple DNS tunnel over websocket')
    parser.add_argument('-b', action='store', dest='bind_address', default='127.0.0.1',
                        help='bind to this address, default to 127.0.0.1')
    parser.add_argument('-p', action='store', dest='bind_port', type=int, default=5353,
                        help='bind to this port, default to 5353')
    parser.add_argument('--debug', action='store_true', dest='debug', default=False,
                        help='enable debug outputing')
    args = parser.parse_args(sys.argv[1:])
    if 'PORT' in os.environ:
        # we are probably in heroku environment
        port = int(os.environ['PORT'])
        addr = '0.0.0.0'
    else:
        port = args.bind_port
        addr = args.bind_address
    if args.debug:
        logging_level = logging.DEBUG
    else:
        logging_level = logging.INFO
    logging.basicConfig(level=logging_level,
                        format='%(asctime)s %(levelname)-8s %(message)s',
                        datefmt='%Y-%m-%d %H:%M:%S')
    start_server = websockets.serve(handle, addr, port)
    asyncio.get_event_loop().run_until_complete(start_server)
    logging.info('listening on %s:%d' % (addr, port))
    asyncio.get_event_loop().run_forever()

def main():
	print("Serving WebSockets on "+config['host']+" port "+config["port"]+" ...")
	temppath = os.path.join(os.path.sep, "tmp")
	start_server = websockets.serve(hello, config['host'], config['port'])

	asyncio.get_event_loop().run_until_complete(start_server)
	asyncio.get_event_loop().run_forever()

def run_server():
    loop = asyncio.get_event_loop()
    server = SimServer(loop=loop)
    start_server = websockets.serve(server, 'localhost', 3000)

    try:
        webbrowser.open(
            "file://{}".format(
                abspath(pjoin(dirname(abspath(__file__)), '..', 'WebDrone', 'index.html'))
            )
        )
        s = loop.run_until_complete(start_server)
        logger.info(
            'simulation is serving on {}'.format(s.sockets[0].getsockname())
        )
        loop.run_forever()
    except KeyboardInterrupt:
        logger.debug('capture ctrl-C in sim main.')
        coros = [
            server.close()
        ]
        loop.run_until_complete(cleanup(coros))
    finally:
        loop.close()
        logger.info("exit.")

def main():
    loop = asyncio.get_event_loop()

    # обычно websocket работают через HTTP(S) порт (80/443); чтобы иметь
    # возможность запускать от non-root пользователя, используем 8765
    start_server = websockets.serve(
        hello,
        WEBSOCKET_SERVER['address'],
        WEBSOCKET_SERVER['port']
    )
    try:
        print(str.format(
            'Try to run websocket server: [{}:{}]',
            WEBSOCKET_SERVER['address'], WEBSOCKET_SERVER['port']
        ))

        loop.run_until_complete(start_server)
    except OSError as e:
        print(str.format('[%] <e>', e))
        sys.exit(1)
    try:
        loop.run_forever()
    except KeyboardInterrupt:
        loop.close()
        print('[*] Websocket server shut down!')

def run_server(host, port):
    logger.info("Starting control server on %s:%d", host, port)

    start_server = websockets.serve(client_handler, host, port)

    asyncio.get_event_loop().run_until_complete(start_server)
    asyncio.get_event_loop().run_forever()

 def __init__(self):
     self.running = False
     self.conn_queues = []
     self.worker_method = self._run
     self.pipe = Pipe()
     super(WebsocketsServer, self).__init__(self)
     self.server = websockets.serve(self.new_conn, 'localhost', 8765)