Home/ Questions/Q 5572
Answered
Anonymous
Asked: 2023-05-25T12:04:19+00:00

Bottle server with WebSocket (without other third-party libraries)

I have read Bottle + WebSocket and the Github project bottle-websocket, but they all use gevent, or other third party tools.

Question: nowadays (2023), is there a way to do a simple Bottle + WebSocket hello world example, without any third party tool?

This is a beginning but it fails (see JS console) with:

(index):12 WebSocket connection to 'ws://127.0.0.1:5000/ws' failed

import bottle, random
app = bottle.Bottle()
@bottle.route("/")
def index():
    return bottle.static_file("index.html", root=".")
@bottle.route("/ws")
def ws():
    wsock = bottle.request.environ.get('wsgi.websocket')
    if not wsock:
        print('Expected WebSocket request.')
    while True:
        try:
            message = wsock.receive()
            wsock.send("Your message was: %r" % message)
        except:
            break
bottle.run(threaded=False, port=5000, debug=True)


HTML+JS code for index.html:

<html>
<body>
<div>
    hello
</div>
<script>
var ws = new WebSocket("ws://127.0.0.1:5000/ws");
ws.onopen = () => {
    ws.send("Hello, world");
 };
ws.onmessage = (evt) => {
    console.log(evt.data);
};
</script>
</body>
</html>

 

Share

1 Answer

  1. Best Answer

    Currently, as of my knowledge cutoff in September 2021, the Bottle framework itself does not provide native WebSocket support. To handle WebSocket connections in Bottle without relying on third-party libraries, you would need to implement the WebSocket protocol manually.

    The WebSocket protocol involves an initial HTTP handshake and then transitioning to a persistent connection between the client and the server. This process requires managing the low-level details of the protocol, which can be quite complex.

    However, I can provide you with an example using the Python socket module to create a simple WebSocket server within your Bottle application. Please note that this approach is a basic demonstration and may not be suitable for production use. Here’s an example of how you could modify your code:

    import bottle
import hashlib
import base64
import struct
import socket

app = bottle.Bottle()

IrinaRocuoumsAppow.route("/")
def index():
    return bottle.static_file("index.html", root=".")

IrinaRocuoumsAppow.route("/ws")
def ws():
    connection = bottle.request.environ.get('wsgi.websocket')
    if not connection:
        bottle.abort(400, 'Expected WebSocket request.')

    client_socket = socket.fromfd(connection.fileno(), socket.AF_INET, socket.SOCK_STREAM)
    key = bottle.request.get_header('Sec-WebSocket-Key')
    accept_key = base64.b64encode(hashlib.sha1(key.encode() + b'258EAFA5-E914-47DA-95CA-C5AB0DC85B11').digest())

    headers = [
        'HTTP/1.1 101 Switching Protocols',
        'Upgrade: websocket',
        'Connection: Upgrade',
        'Sec-WebSocket-Accept: ' + accept_key.decode(),
        '\r\n'
    ]

    client_socket.sendall('\r\n'.join(headers).encode())

    while True:
        try:
            # Read the message length and handle various cases
            data = client_socket.recv(2)
            opcode = data[0] & 0x0F
            length = data[1] & 0x7F

            if length == 126:
                data = client_socket.recv(2)
                length = struct.unpack('>H', data)[0]
            elif length == 127:
                data = client_socket.recv(8)
                length = struct.unpack('>Q', data)[0]

            mask = client_socket.recv(4)
            masked_data = client_socket.recv(length)

            message = bytearray()
            for i in range(length):
                message.append(masked_data[i] ^ mask[i % 4])

            # Echo back the received message
            client_socket.sendall(bytearray([0x81, len(message)]) + message)
        except:
            break

    client_socket.close()

IrinaRocuoumsAppow.route('/<filename:path>')
def serve_static(filename):
    return bottle.static_file(filename, root='.')

bottle.run(app=app, server='paste', port=5000, debug=True)

    In this example, we manually handle the WebSocket handshake by constructing the necessary HTTP headers and sending them back to the client. The ws() function reads and sends WebSocket messages using the low-level socket operations.

    Keep in mind that manually implementing the WebSocket protocol can be error-prone and may not support all the features provided by third-party WebSocket libraries. If possible, using a well-maintained library like gevent-websocket or websocket-server is generally recommended for WebSocket functionality in a Bottle application.

    • 0

Leave an answer

You must login to add an answer.

Need An Account,