def start(self):
"""
Called by SocketShark to initialize the server and prepare & run
SocketShark.
"""
async def serve(websocket, path):
client = Client(self.shark, websocket)
await client.consumer_handler()
config = self.shark.config
loop = asyncio.get_event_loop()
loop.run_until_complete(self.shark.prepare())
ssl_context = self.shark.get_ssl_context()
start_server = websockets.serve(serve,
config['WS_HOST'],
config['WS_PORT'],
ssl=ssl_context)
self.server = loop.run_until_complete(start_server)
self.shark.signal_ready()
loop.run_until_complete(self.shark.run())
loop.run_forever()
loop.run_until_complete(self.shutdown())
self.shark.signal_shutdown()
python类serve()的实例源码
def handle(self, generator):
self.clients = []
async def server(client, _):
self.clients.append(client)
for state in generator:
await client.send(json.dumps(state.to_dict()))
asyncio.set_event_loop(
asyncio.new_event_loop()
)
asyncio.get_event_loop().run_until_complete(
websockets.serve(server, self.args.get('ws_host'), self.args.get('ws_port'))
)
asyncio.get_event_loop().run_forever()
def serve(self):
self.initialize()
self.challenge_thread = ChallengeThread.ChallengeThread(self)
self.challenge_thread.start()
if self.ssl_on:
ssl_context = ssl.SSLContext(protocol=ssl.PROTOCOL_SSLv23)
ssl_context.load_cert_chain(self.ssl_cert)
self.server_socket = websockets.serve(
self.handle_connection, self.listen_address, self.port, ssl=ssl_context)
else:
self.server_socket = websockets.serve(
self.handle_connection, self.listen_address, self.port)
try:
asyncio.get_event_loop().run_until_complete(self.server_socket)
asyncio.get_event_loop().run_forever()
except KeyboardInterrupt:
print("Closing the server")
asyncio.get_event_loop().close()
def __init__(self, websock_uri, connections, loop, logger):
"""
Initialize new instance
:param websock_uri: Tuple containing hostname and port for websocket server
:param connections: Reference to ClientConnections class through which are
sent messages from other threads. Note, that this must be invoked thread
safe via given message loop of asyncio module.
:param loop: Asyncio message loop for handling connections
:param logger: System logger instance
"""
super().__init__()
self._connections = connections
self._loop = loop
self._logger = logger
hostname, port = websock_uri
asyncio.set_event_loop(loop)
start_server = websockets.serve(self.connection_handler, hostname, port)
loop.run_until_complete(start_server)
self._logger.info("websocket server initialized at {}:{}".format(hostname, port))
def serve(self):
self.initialize()
self.challenge_thread = ChallengeThread.ChallengeThread(self)
self.challenge_thread.start()
if self.ssl_on:
ssl_context = ssl.SSLContext(protocol=ssl.PROTOCOL_SSLv23)
ssl_context.load_cert_chain(self.ssl_cert)
self.server_socket = websockets.serve(self.handle_connection, self.listen_address, self.port, ssl=ssl_context)
else:
self.server_socket = websockets.serve(self.handle_connection, self.listen_address, self.port)
try:
asyncio.get_event_loop().run_until_complete(self.server_socket)
asyncio.get_event_loop().run_forever()
except KeyboardInterrupt:
print("Closing the server")
asyncio.get_event_loop().close()
def init_task(self, flags):
"""dude people are gonna send voice packets of them crying"""
async def voice_henlo(ws, path):
log.info(f'[vws] new connection at {path}')
v_conn = VoiceConnection(ws, server=self, path=path)
await v_conn.run()
vws = flags['server']['voice_ws']
log.info(f'[voice_ws] running at {vws[0]}:{vws[1]}')
self.vws_tuple = vws
ws_server = websockets.serve(voice_henlo, host=vws[0], port=vws[1])
await ws_server
return True
def serve(socket, path):
req = await socket.recv()
try:
req = loads(req)
if req.get("cmd") == "all":
res = model.everything
if req.get("cmd") == "search":
res = model.similar(req.get("query") or "Ling is weird")
elif req.get("cmd") == "node":
res = model.doc(req.get("id"))
else:
res = {"resp": "err"}
res = dumps(res)
await socket.send(res)
except JSONDecodeError:
await socket.send(dumps({"resp": "err"}))
def main():
start_server = websockets.serve(handler, '0.0.0.0', CONFIG['websocket']['port'])
asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()
def setup_tasks(self):
super().setup_tasks()
start_server = websockets.serve(echo_time, '127.0.0.1', 65432)
asyncio.ensure_future(start_server, loop=self.loop)
def serve(self):
return websockets.serve(self.handle_client, self.host, self.port)
def run_server(gimbal, **kw):
server = SocketServer(gimbal, **kw)
loop = asyncio.get_event_loop()
loop.run_until_complete(server.serve())
print("Server running at %s" % server.uri())
loop.run_forever()
def configure(self, parser, host='localhost', port=8765):
self._server = websockets.serve(self.handler, host, port)
self._parser = parser
def run(self):
"""
This is a blocking call.
"""
self.loop.create_task(self.heartbeat())
start_server = websockets.serve(self.ws_handler, "0.0.0.0", 5555, loop=self.loop)
self.loop.run_until_complete(start_server)
self.loop.run_forever()
def start(self):
start_server = websockets.serve(
self.handler, '0.0.0.0', WS_SERVER_PORT)
print(" **** starting debug socket server...")
asyncio.get_event_loop().create_task(start_server)
def main():
start_server = websockets.serve(handler, 'localhost', 8000)
asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()
def run(self):
logger.info('Starting server')
self.websocket_server = websockets.serve(self.handler, self.host, self.port, timeout=60)
self.loop.run_until_complete(self.websocket_server)
asyncio.async(wakeup()) #HACK so keyboard interrupt works on Windows
self.loop.run_forever()
self.loop.close()
self.clean_up()
def start(self, address, port):
start_server = serve(self.server, address, port)
get_event_loop().run_until_complete(start_server)
get_event_loop().run_forever()
def run(self):
self.logger = logging.getLogger("websocket")
self.logger.info("Starting OverStream Websocket on Port {port}".format(port=self.PORT))
print(self.plugin_engine.get_data())
start_server = websockets.serve(self.websocket_connection, 'localhost', self.PORT)
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()
def run(self, host='192.168.1.9', port=25565):
start_server = websockets.serve(self.handler, host, port)
asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()
def run(self):
"""
Function to start websocket server, which handle and serve all connections.
:return: This function returns when given message loop is stopped and returns
nothing.
"""
asyncio.set_event_loop(self._loop)
self._loop.run_forever()
def test_send_command_can_trigger_on_event_prior_to_commmand_containing_event_id(event_loop, chrome_tab):
msg_id = 4
frame_id = '3228.1'
url = 'http://example.com'
chrome_tab._message_id = msg_id - 1
f = page.Frame(frame_id, 'test', url, 'test', 'text/html')
p = page.Page.navigate(url)
fe = page.FrameNavigatedEvent(f)
ack = {'id': msg_id, 'result': {'frameId': frame_id}}
triggers = {
msg_id: [ack]
}
end_msg = copy.copy(p[0])
end_msg['id'] = msg_id
q = queue.Queue()
q.put(end_msg)
initial_msgs = [fe]
test_server = init_test_server(triggers, initial_msgs=initial_msgs, expected=q)
start_server = websockets.serve(test_server, TEST_HOST, TEST_PORT)
server = await start_server
await chrome_tab.connect()
log.info('Sending command and awaiting...')
result = await chrome_tab.send_command(p, await_on_event_type=page.FrameNavigatedEvent)
assert result.get('ack') is not None
assert result.get('event') is not None
event = result.get('event')
assert isinstance(event, page.FrameNavigatedEvent)
assert event.frame.id == f.id
assert event.frame.url == f.url
server.close()
await server.wait_closed()
def test_send_command_can_trigger_on_event_after_commmand_containing_event_id(event_loop, chrome_tab):
msg_id = 4
frame_id = '3228.1'
url = 'http://example.com'
chrome_tab._message_id = msg_id - 1
f = page.Frame(frame_id, 'test', url, 'test', 'text/html')
p = page.Page.navigate(url)
fe = page.FrameNavigatedEvent(f)
ack = {'id': msg_id, 'result': {'frameId': frame_id}}
triggers = {
msg_id: [ack, delay_s(1), fe]
}
end_msg = copy.copy(p[0])
end_msg['id'] = msg_id
q = queue.Queue()
q.put(end_msg)
q.put(copy.copy(end_msg))
test_server = init_test_server(triggers, expected=q)
start_server = websockets.serve(test_server, TEST_HOST, TEST_PORT)
server = await start_server
await chrome_tab.connect()
log.info('Sending command and awaiting...')
result = await chrome_tab.send_command(p, await_on_event_type=page.FrameNavigatedEvent)
assert result.get('ack') is not None
assert result.get('event') is not None
event = result.get('event')
assert isinstance(event, page.FrameNavigatedEvent)
assert event.frame.id == f.id
assert event.frame.url == f.url
server.close()
await server.wait_closed()
def start_server(self):
logger.info('server starting up')
self.server = await websockets.serve(self.handle_new_connection, '0.0.0.0', self.port, timeout=1)
def start_app(host='127.0.0.1', port=5000, debug=True, log_level=logging.DEBUG, **ws_options):
"""Start the portkey app running in the event loop. This function should run once and only once for a portkey app.
Args:
host: The hostname to listen on. Set this to '0.0.0.0' to have the server available externally
port: The port of the server
debug: Whether to automatically reload the program when the code is modified
log_level: The log level to be passed to Portkey logger
**ws_options: Other options to be passed to `websockets.serve()`
"""
starter_function = functools.partial(_start_app, host=host, port=port, log_level=log_level, **ws_options)
if debug:
run_with_reloader(starter_function)
else:
starter_function()
def start_server(self):
""" Start the websocket server """
self._serv = self.loop.run_until_complete(
websockets.serve(
self._accept_client,
host=self.ip,
port=self.port,
loop=self.loop,
)
)
return self._serv
def serve(self):
port = self.settings.port
return await websockets.serve(self._accept, "localhost", port)
def start_ws(settings):
gateway = Gateway(settings)
tasks = [gateway.serve()]
# Handle CTRL-C
def signal_handler():
print("Stopping darkwallet-daemon...")
gateway.stop()
loop.stop()
loop.add_signal_handler(signal.SIGINT, signal_handler)
loop.run_until_complete(asyncio.wait(tasks))
loop.run_forever()
def serve(self, websocket, path):
success = True
while success:
message = await websocket.recv()
success = await self.process(websocket, message)
print("resp", len(json.dumps(success)))
await websocket.send(json.dumps(success))
def start(settings):
loop = zmq.asyncio.ZMQEventLoop()
asyncio.set_event_loop(loop)
context = libbitcoin.server.Context()
darkwallet = Gateway(context, settings, loop)
tasks = [
websockets.serve(darkwallet.serve, 'localhost', 8888)
]
tasks.extend(context.tasks())
loop.run_until_complete(asyncio.wait(tasks))
loop.close()
def run(ip, port, *, client_timeout:int=45, request_timeout:int=2):
print('Starting server...')
requests.timeout_delay = client_timeout
requests.request_timeout = request_timeout
start_server = websockets.serve(requests.handler, ip, port)
asyncio.get_event_loop().run_until_complete(start_server)
print('Server started and listening for requests.')
asyncio.get_event_loop().run_forever()
