Python Language
Websockets

Simple Echo avec aiohttp

aiohttp fournit des aiohttp asynchrones.

import asyncio
from aiohttp import ClientSession

with ClientSession() as session:
    async def hello_world():

        websocket = await session.ws_connect("wss://echo.websocket.org")

        websocket.send_str("Hello, world!")

        print("Received:", (await websocket.receive()).data)

        await websocket.close()

    loop = asyncio.get_event_loop()
    loop.run_until_complete(hello_world())

Classe d'emballage avec aiohttp

aiohttp.ClientSession peut être utilisé comme parent pour une classe WebSocket personnalisée.

import asyncio
from aiohttp import ClientSession

class EchoWebSocket(ClientSession):

    URL = "wss://echo.websocket.org"

    def __init__(self):
        super().__init__()
        self.websocket = None

    async def connect(self):
        """Connect to the WebSocket."""
        self.websocket = await self.ws_connect(self.URL)

    async def send(self, message):
        """Send a message to the WebSocket."""
        assert self.websocket is not None, "You must connect first!"
        self.websocket.send_str(message)
        print("Sent:", message)

    async def receive(self):
        """Receive one message from the WebSocket."""
        assert self.websocket is not None, "You must connect first!"
        return (await self.websocket.receive()).data

    async def read(self):
        """Read messages from the WebSocket."""
        assert self.websocket is not None, "You must connect first!"

        while self.websocket.receive():
            message = await self.receive()
            print("Received:", message)
            if message == "Echo 9!":
                break

async def send(websocket):
    for n in range(10):
        await websocket.send("Echo {}!".format(n))
        await asyncio.sleep(1)

loop = asyncio.get_event_loop()

with EchoWebSocket() as websocket:

    loop.run_until_complete(websocket.connect())

    tasks = (
        send(websocket),
        websocket.read()
    )

    loop.run_until_complete(asyncio.wait(tasks))

    loop.close()

Utiliser Autobahn comme une usine Websocket

Le package Autobahn peut être utilisé pour les fabriques de serveurs Web socket Python.

Documentation du package Python Autobahn

Pour installer, il suffit généralement d'utiliser la commande terminal

(Pour Linux):

sudo pip install autobahn

(Pour les fenêtres):

python -m pip install autobahn

Ensuite, un serveur d'écho simple peut être créé dans un script Python:

from autobahn.asyncio.websocket import WebSocketServerProtocol
class MyServerProtocol(WebSocketServerProtocol):
    '''When creating server protocol, the
    user defined class inheriting the 
    WebSocketServerProtocol needs to override
    the onMessage, onConnect, et-c events for 
    user specified functionality, these events 
    define your server's protocol, in essence'''
    def onMessage(self,payload,isBinary):
        '''The onMessage routine is called 
        when the server receives a message.
        It has the required arguments payload 
        and the bool isBinary. The payload is the 
        actual contents of the "message" and isBinary
        is simply a flag to let the user know that 
        the payload contains binary data. I typically 
        elsewise assume that the payload is a string.
        In this example, the payload is returned to sender verbatim.'''
        self.sendMessage(payload,isBinary)
if__name__=='__main__':
    try:
        importasyncio
    except ImportError:
        '''Trollius = 0.3 was renamed'''
        import trollius as asyncio
    from autobahn.asyncio.websocketimportWebSocketServerFactory
    factory=WebSocketServerFactory()
    '''Initialize the websocket factory, and set the protocol to the 
    above defined protocol(the class that inherits from 
    autobahn.asyncio.websocket.WebSocketServerProtocol)'''
    factory.protocol=MyServerProtocol
    '''This above line can be thought of as "binding" the methods
    onConnect, onMessage, et-c that were described in the MyServerProtocol class
    to the server, setting the servers functionality, ie, protocol'''
    loop=asyncio.get_event_loop()
    coro=loop.create_server(factory,'127.0.0.1',9000)
    server=loop.run_until_complete(coro)
    '''Run the server in an infinite loop'''
    try:
        loop.run_forever()
    except KeyboardInterrupt:
        pass
    finally:
        server.close()
        loop.close()

Dans cet exemple, un serveur est en cours de création sur l'hôte local (127.0.0.1) sur le port 9000. Il s'agit de l'adresse IP et du port d'écoute. Ce sont des informations importantes, car en utilisant cela, vous pouvez identifier l'adresse LAN et le port de votre ordinateur à partir de votre modem, bien que tous les routeurs que vous avez sur l'ordinateur. Ensuite, en utilisant Google pour étudier votre adresse IP WAN, vous pouvez concevoir votre site Web pour envoyer des messages WebSocket à votre IP WAN, sur le port 9000 (dans cet exemple).

Il est important de transférer votre modem vers l'arrière, ce qui signifie que si vous avez des routeurs connectés en guirlande au modem, entrez les paramètres de configuration du modem, le port du modem vers le routeur connecté, etc., jusqu'au routeur final de votre ordinateur. est connecté est d'avoir l'information reçue sur le port modem 9000 (dans cet exemple) qui lui est transféré.