CODEWITHSUNDEEP
javascriptwebsocketgo
Aniruddh Chaturvedi
Aniruddh Chaturvedi

Reputation: 649

Javascript websockets closing immediately after opening

connection = new WebSocket("ws://localhost:1050/join?username=test")

connection.onopen = function(){
   alert('Connection open!');
}


connection.onmessage = function(e){
   var server_message = e.data;
   alert(server_message);
}

connection.onclose = function() {
    alert("websocket closing")
}

The connection to the server is established and an alert is displayed for Connection open! However immediately afterwards the connection closes. The server does not call close and there seem to be no other errors in the console. This is happening in both chrome and firefox.

I looked at a bunch of different similar examples on the web but to no avail.

Upvotes: 12

Views: 27972

Answers (7)

Kousik Pandey
Kousik Pandey

Reputation: 21

websockets version 14.0 has some issues in handling connections. downgrading to a version e.g. - 12.0 solves the issue.

In version 14.0, they have changed a few things including -

  1. Handshake and Header Handling
  2. UTF-8 Decoding and Message Fragmentation
  3. Changes to Connection Status Properties

The clients which were working with (at least) version 12.0, needs to change their implementation to cope up with the new implementation of websockets.

Upvotes: 0

Jaeba
Jaeba

Reputation: 31

Piecing together hints from this post and others, I found a solution that works when using the python websocket server example found everywhere that includes something like:

async def handler(websocket, path):
    data = await websocket.recv()
    reply = f"Data recieved as: {data}!"
    await websocket.send(reply)

To those of us new to websocket, I think the assumption is that the handler function will be called each time the client sends a message, which turns out not to be the case. As others mention, the connection closes as soon as the handler function returns once. The solution I found is to change it to:

async def handler(websocket, path):
    async for data in websocket:
        reply = f"Data recieved as: {data}!"
        print(data)
        await websocket.send(reply)

My client-side javascript code is equivalent to the OP's and I didn't have to change anything for this to work.

Unfortunately I can't explain why async for data in websocket: makes it actually wait forever and spontaneously run the inner code block each time a message is received, but it does for me and I get all the expected log messages both on the python server side and the client javascript console.

If anyone more knowledgeable on this topic can comment on whether this is a good-for-general-use solution or if there's a gotcha to look out for here, it would be much appreciated.

Upvotes: 1

Hisham Karam
Hisham Karam

Reputation: 1318

to Keep Websocket Opened prevent handler from returning by return false; in connection.onmessage like this :

connection.onmessage = function(e){
   var server_message = e.data;
   alert(server_message);
   return false;
}

Upvotes: 12

Syriven
Syriven

Reputation: 125

I believe I've stumbled across the solution that OP found but failed miserably to explain. I don't have enough reputation to comment, otherwise I'd be responding to all of the confused comments begging for clarification on OP's response.

The short version is that I think OP was referring to his server-side connection handler when he said "All I had to do was block the handler from returning before the websocket connection closes".

It turns out my server was closing the webSocket automatically because I didn't understand how a certain webSocket function worked. Specifically, I was using a Python server script with asyncio/websockets and the following code:

async def receiveCommandsLoop(player):
    while True:
        msg = await player.websocket.recv()
        print(command)

async def handleClient(websocket, path):
    username = await websocket.recv()
    player = players[username]

    ...

    #Start task to listen for commands from player
    asyncio.get_event_loop().create_task(receiveCommandsLoop(player))

start_server = websockets.serve(handleClient, '', 8765)

The idea was that websockets.serve would use handleClient to begin the connection and do some setup, then create a new task with receiveCommandsLoop that would take over the job of communication.

But it turns out: when you call websockets.serve, Python expects that when your handler (in this case, handleClient) returns, you must be done with the socket, and it closes it automatically.

Thus, by the time receiveCommandsLoop was run, handleClient had returned, and the webSocket had been automatically closed.

I was able to fix this by simply modifying my handleClient function to directly run the loop originally contained in receiveCommandsLoop. Hope this helps someone out there.

Upvotes: 9

Lone Ronin
Lone Ronin

Reputation: 2870

It could also be a login problem. The websocket will automatically close the website required authentication but no authentication information was provided.

Upvotes: 0

Andrew Kravchuk
Andrew Kravchuk

Reputation: 396

This also could be the case when you're trying to send binary data over a websocket connection, but some side (client or server) is trying to interpret it as a text - many libraries and frameworks do it unless you explicitly specify you do want binary data.

Upvotes: 0

Aniruddh Chaturvedi
Aniruddh Chaturvedi

Reputation: 649

Fixed it!

All I had to do was block the handler from returning before the websocket connection closes

Upvotes: -8

Related Questions