Esempio n. 1
0
    def set_up(self, ip, port, loop=None, ssl=None):
        if ssl is None:
            self.server = asyncws.start_server(self.handle_client,
                                               ip,
                                               port,
                                               ssl=ssl)
        else:
            self.server = asyncws.start_server(self.handle_client, ip, port)

        if loop is None:
            self.loop = asyncio.get_event_loop()
        else:
            self.loop = loop
            asyncio.set_event_loop(self.loop)

        self.loop.add_reader(self.rsocket, self.stop)
        self.loop.run_until_complete(self.server)
Esempio n. 2
0
clients_lock = asyncio.Lock()


def chat(websocket):

    with (yield from clients_lock):
        clients.append(websocket)

    try:
        while True:
            frame = yield from websocket.recv()
            if frame is None:
                break

            client_copy = None
            with (yield from clients_lock):
                client_copy = list(clients)

            for client in client_copy:
                if client is websocket:
                    continue
                yield from client.send(frame)
    finally:
        with (yield from clients_lock):
            clients.remove(websocket)


server = asyncws.start_server(chat, "127.0.0.1", 8000)
asyncio.get_event_loop().run_until_complete(server)
asyncio.get_event_loop().run_forever()
Esempio n. 3
0
import asyncio
import asyncws


@asyncio.coroutine
def echo(websocket):
    while True:
        frame = yield from websocket.recv()
        if frame is None:
            break
        yield from websocket.send(frame)


loop = asyncio.get_event_loop()
server = loop.run_until_complete(asyncws.start_server(echo, '127.0.0.1', 8000))
try:
    loop.run_forever()
except KeyboardInterrupt as e:
    server.close()
    loop.run_until_complete(server.wait_closed())
finally:
    loop.close()
Esempio n. 4
0
    for client in client_copy:
        yield from client.send("Connected %s" % peer)

    try:
        while True:
            frame = yield from websocket.recv()
            if frame is None:
                break

            with (yield from clients_lock):
                client_copy = list(clients)

            text = "%s> %s" % (peer, str(frame))

            for client in client_copy:
                if client is websocket:
                    continue

                yield from client.send(text)
    finally:
        with (yield from clients_lock):
            clients.remove(websocket)
            client_copy = list(clients)

        for client in client_copy:
            yield from client.send("Disconnected %s" % peer)

server = asyncws.start_server(chat, '127.0.0.1', 8000)
asyncio.get_event_loop().run_until_complete(server)
asyncio.get_event_loop().run_forever()
                          data_path, frames_length, frame_id)
                fp = open(os.path.join(data_path, frame_names[frame_id]), "rb")
                content = fp.read()
                fp.close()
                yield from websocket.send(content, True)
                yield from asyncio.sleep(frame_interval)
                frame_id += 1
            except ConnectionResetError:
                LOG.info("websocket close, path: %s", websocket.request.path)
                break
    except Exception as e:
        LOG.exception(e)


if __name__ == "__main__":
    logger.config_logging(file_name="test.log",
                          log_level="DEBUG",
                          dir_name="logs",
                          day_rotate=False,
                          when="D",
                          interval=1,
                          max_size=20,
                          backup_count=5,
                          console=True)
    LOG.info("websocket server start")
    LOG.info("service: %s:%s", HOST, PORT)
    server = asyncws.start_server(test_websocket_service, HOST, PORT)
    asyncio.get_event_loop().run_until_complete(server)
    asyncio.get_event_loop().run_forever()
    LOG.info("websocket server end")
Esempio n. 6
0
import asyncio
import asyncws
import ssl


@asyncio.coroutine
def echo(websocket):
    while True:
        frame = yield from websocket.recv()
        if frame is None:
            break
        yield from websocket.send(frame)


ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
ssl_context.check_hostname = False
ssl_context.load_cert_chain('example.crt', 'example.key')

loop = asyncio.get_event_loop()
loop.set_debug(True)
server = loop.run_until_complete(
    asyncws.start_server(echo, '127.0.0.1', 8000, ssl=ssl_context))
try:
    loop.run_forever()
except KeyboardInterrupt as e:
    server.close()
    loop.run_until_complete(server.wait_closed())
finally:
    loop.close()
Esempio n. 7
0
import asyncio
import asyncws

@asyncio.coroutine
def echo(websocket):
    while True:
        frame = yield from websocket.recv()
        if frame is None:
            break
        yield from websocket.send(frame)


loop = asyncio.get_event_loop()
server = loop.run_until_complete(
    asyncws.start_server(echo, '127.0.0.1', 8000))
try:
    loop.run_forever()
except KeyboardInterrupt as e:
    server.close()
    loop.run_until_complete(server.wait_closed())
finally:
    loop.close()
Esempio n. 8
0
import asyncio
import asyncws
import ssl

@asyncio.coroutine
def echo(websocket):
    while True:
        frame = yield from websocket.recv()
        if frame is None:
            break
        yield from websocket.send(frame)


ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
ssl_context.check_hostname = False
ssl_context.load_cert_chain('example.crt', 'example.key')

loop = asyncio.get_event_loop()
loop.set_debug(True)
server = loop.run_until_complete(
    asyncws.start_server(echo, '127.0.0.1', 8000, ssl=ssl_context))
try:
    loop.run_forever()
except KeyboardInterrupt as e:
    server.close()
    loop.run_until_complete(server.wait_closed())
finally:
    loop.close()

Esempio n. 9
0
        yield from client.send("Connected %s" % peer)

    try:
        while True:
            frame = yield from websocket.recv()
            if frame is None:
                break

            with (yield from clients_lock):
                client_copy = list(clients)

            text = "%s> %s" % (peer, str(frame))

            for client in client_copy:
                if client is websocket:
                    continue

                yield from client.send(text)
    finally:
        with (yield from clients_lock):
            clients.remove(websocket)
            client_copy = list(clients)

        for client in client_copy:
            yield from client.send("Disconnected %s" % peer)


server = asyncws.start_server(chat, '127.0.0.1', 8000)
asyncio.get_event_loop().run_until_complete(server)
asyncio.get_event_loop().run_forever()
Esempio n. 10
0
import asyncio
import asyncws

@asyncio.coroutine
def echo(websocket):
    while True:
        frame = yield from websocket.recv()
        if frame is None:
            break
        yield from websocket.send(frame)

server = asyncws.start_server(echo, '127.0.0.1', 8000)
asyncio.get_event_loop().run_until_complete(server)
asyncio.get_event_loop().run_forever()