just run the example app.py, got this 404 error

INFO: 139.227.183.235:9697 - "GET /socket.io/?EIO=4&transport=polling&t=OVNl-ba HTTP/1.1" 404 Not Found
INFO: 139.227.183.235:9697 - "GET /socket.io/?EIO=4&transport=polling&t=OVNl_pi HTTP/1.1" 404 Not Found
INFO: 139.227.183.235:9697 - "GET /socket.io/?EIO=4&transport=polling&t=OVNl_sU HTTP/1.1" 404 Not Found
INFO: 139.227.183.235:9697 - "GET /socket.io/?EIO=4&transport=polling&t=OVNm03J HTTP/1.1" 404 Not Found
INFO: 139.227.183.235:9697 - "GET /socket.io/?EIO=4&transport=polling&t=OVNm066 HTTP/1.1" 404 Not Found
INFO: 139.227.183.235:9697 - "GET /socket.io/?EIO=4&transport=polling&t=OVNm08u HTTP/1.1" 404 Not Found

Hi,

Within VSCode I'm getting some type errors:

Cannot access member "sio" for type "FastAPI"
  Member "sio" is unknown

Which makes sense because as far as VSCode knows FastAPI doesn't have an attribute sio. Is there a way this can be fixed ? For example adding custom stub types ?

Thanks

Improve type hinting for SocketManager

Where to set pingTimeout for server https://socket.io/docs/v4/server-options/#pingtimeout ?

I am a newbie and trying to figure out authentication. Are there any guidelines on the same? I was able to add extra_headers on client side, but unable to find any way to get and validate headers on serverside for fastapi-socketio

I'm currently trying to work this module into my Server. I tried to test it via

`if name == "main":
app = FastAPI()
socket_manager = SocketManager(app=app)
uvicorn.run(app, host="localhost", port=40000)

@app.sio.on('join')
async def handle_join(sid, *args, **kwargs):
    await app.sio.emit('lobby', 'User joined')


@app.sio.event
async def connect(sid, environ):
    print(f"client {sid} has connected to the server")

`

i want to run my socketio on my /socket.io route is it possible via this module, since mounting the normal socket.io to fastapi results in a 404 route not found.

I'm hitting a 403 locally. Been trying to debug for days.

from flask_socketio import SocketIO
from flask_cors import CORS
from fastapi import FastAPI, WebSocket, Depends
from fastapi_socketio import SocketManager
from fastapi.middleware.cors import CORSMiddleware
from fastapi.staticfiles import StaticFiles
from fastapi.responses import FileResponse

app = FastAPI()
app.mount("/static", StaticFiles(directory="front/build", html=True), name="static")

socket_manager = SocketManager(app=app)

Set CORS

origins = [
"http://localhost:3000"
]

app.add_middleware(
CORSMiddleware,
allow_origins=origins,
allow_credentials=True,
allow_methods=[""],
allow_headers=[""],
)

GAME_NAMESPACE = "/game"

if name == "main":
# LOCAL
port = int(os.environ.get("PORT", 5001))
import uvicorn
uvicorn.run(app, host="127.0.0.1", port=port, log_level="info")

On Client:
const SERVER_URL = 'http://127.0.0.1:5001';
const GAME_NAMESPACE = '/game';

To run locally I'm using:
uvicorn server:app --reload --port 5001.

ERRORS:
WebSocket connection to 'ws://127.0.0.1:5001/socket.io/?EIO=4&transport=websocket' failed
INFO: ('127.0.0.1', 51879) - "WebSocket /socket.io/?EIO=4&transport=websocket" 403
INFO: connection failed (403 Forbidden)
INFO: connection closed

Any ideas?

Add allowed CORS origins support based upon current state of FastAPI app.

If FastAPI app does have CORS middleware mounted set SocketManager allowed origins to empty list.

Passing it empty list will make sure that app doesn't break.

It may be desired (as in my case) to not use the AsyncServer, could allow an argument in the constructor to choose which server type to use.

Hey, how can i write my sockets on other folder/file and to tell my main.py to execute them?

my main file:

from fastapi import FastAPI
from starlette.middleware.cors import CORSMiddleware


def get_application():
    app = FastAPI(title="Evil Islands", version="1.0.0", redoc_url=None)
    app.add_middleware(
        CORSMiddleware,
        allow_origins=["http://localhost:8080"],
        allow_credentials=True,
        allow_methods=["*"],
        allow_headers=["*"],
    )

    return app


app = get_application()

I want to place @app.sio listeners to a directory - lets say ../sockets

thank you.

I try to run the package but received this error:

127.0.0.1:51474 - "GET /socket.io/?EIO=3&transport=polling&t=NOi5NZ- HTTP/1.1" 404 Not Found

This is my code

from fastapi import FastAPI
from fastapi_socketio import SocketManager

app = FastAPI()

sio = SocketManager(app=app, cors_allowed_origins=["*"])

@app.get("/")
def read_root():
    return {"Hello": "World"}

@sio.on('connect')
async def connect():
    print('connect')

if __name__ == '__main__':
    import logging
    import sys

    logging.basicConfig(level=logging.DEBUG,
                        stream=sys.stdout)

    import uvicorn

    uvicorn.run("main:app", host='127.0.0.1',
                port=8000, reload=True, debug=False)

Hi, I've got a pretty bare-bones FastAPI new project with fastapi-socketio, and socket.io-client. I set up a simple set-timeout to socket.emit() from the client, but it just disconnects / reconnects. I'lll see if I can show some code soon, but posting first in case there's a common known solution for this?

Hey, could you provide a minimal example how to test the socket manager functions, preferably using FastAPI TestClient?

main.py

from fastapi import FastAPI
from fastapi_socketio import SocketManager

app = FastAPI()
socket_manager = SocketManager(app=app)


@app.get("/")
async def root():
    return {"message": "Hello World"}


@app.sio.on('connect')
async def handle_connect(sid, *args, **kwargs):
    await app.sio.emit('connect', 'User joined')

CLIENT SIDE

import {io} from 'socket.io-client';

const socket =  io('ws://127.0.0.1:8000', {
      path: 'ws/socket.io',
      autoConnect: true
  })

  socket.on('connect', (data) => {
    console.log(data)
  })``` 

i see that i can emit to specific room but no way to join clients to certain rooms. Any help would be appreciated

Hi there.
I just noticed when using your module that a lot of modules got pulled in.
In particular, the netifaces module is pulled in, which is a binary extension. And others.
Browsing your code, I can't see that there are other direct dependencies than fastapi and python-socketio. But the Pipfile includes a host of extensions, and so does setup.py. (python-engineio is automatically added as part of python-socketio)
Not sure why the module needs the various "extras" in setup.py, since there is no extras code.

After adding both CORSMiddleware from FastApi and using SocketManager, which adds another CORS head, it results in the following error when trying to connect from the client:

The 'Access-Control-Allow-Origin' header contains multiple values 'http://localhost:4200, http://localhost:4200', but only one is allowed.

This is my fast api set up code:

app = FastAPI()

app.add_middleware(
    CORSMiddleware,
    allow_origins=['http://localhost:4200'],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

socket_manager = SocketManager(app=app, async_mode="asgi", cors_allowed_origins="*")

The first CORS middleware access is so that the client can query the API but then the socketmanager also adds its own header.

Any solutions / help would be much appreciated!

Hello,

I am using FastAPI with socketIO and using socket emit(Javascript) for sending client button "onclick" event to server which listens to this event and then emits some data after calculation. This works perfectly fine on laptop browser, however when I tested upon mobile browser(Chrome), the button click does not work. I tested on mobile browser with a simple Javascript alert after removing the emit function and it works. So it appears like, the issue is with socket emit.

Here is my Server Code:

from fastapi import FastAPI, Request
import json
from fastapi_socketio import SocketManager
import uvicorn
import time
import subprocess
import asyncio
from fastapi.templating import Jinja2Templates
from fastapi.responses import HTMLResponse
import socketio
from fastapi.staticfiles import StaticFiles


app = FastAPI()
sio = socketio.AsyncServer(cors_allowed_origins='*', async_mode='asgi')
socketio_app = socketio.ASGIApp(sio, app)
templates = Jinja2Templates(directory="templates")
app.mount("/static", StaticFiles(directory="static"), name="static")

@sio.on('my_event')
async def servermessage(data):
    data = asyncio.create_task(ssh())
    while True:
        if data.done():
            value = data.result()
            await sio.emit('response',"SSH Status:" + " " + value)
            break
        else:
            await sio.emit('response', "SSH Status:" + " " + "Please Wait..")



async def ssh():
    cmd1 = 'systemctl status sshd| grep Active | awk -F " " \'{print$2}\''
    listing1 = subprocess.run(cmd1,stdout=subprocess.PIPE,shell=True,universal_newlines=True)
    result = listing1.stdout
    await asyncio.sleep(8)
    return result

@app.get("/", response_class=HTMLResponse)
async def main(request: Request):
    return templates.TemplateResponse("base.html", {"request":request})

Here is my Javascript

<script type="text/javascript" charset="utf-8">
const socket = io("http://fastapi:8000");
socket.on('connect', function (data) {
  console.log('Successfully connected!');
});

function myupdate(event) {
	socket.emit("my_event", function(msg) {
       });
}
socket.on('response', function (data) {
	if(data.includes("Please")) {
		document.getElementById("sshimg").style.display="block";
		document.getElementById("ssh").innerHTML=data;
	} else {
		document.getElementById("sshimg").style.display="none";
		document.getElementById("ssh").innerHTML=data;
	}

});
</script>
  </head>
  <body>
<center>
<h1 style="color:black;background-color:#33ACFF;padding:30px">Welcome to Websockets</h1>
</center>
<br>
<button class="btn btn-info" id="button1" style="margin:5px" onClick="myupdate()">Check Services</button>
	    <p id="ssh" style="font-weight:bold;"></p>
	    <img id="sshimg" style="display:none;margin-left: auto;margin-right: auto;"  src="/static/Spinner.svg" alt="Trulli" width="70" height="70">
</body>
</html>

In my case, I have problem with import everything from main file (with fastapi app object).
https://github.com/michaldev/problem-with-fastapi-import

Access to the app object is not required for other libraries.

Setup test suit and add basic unit tests

this is to allow the registration of class based namespaces as described in the docs: python-socketio: Class-Based Namespaces

simply add this to the end of socket_manager.py

@property
def register_namespace(self):
    return self._sio.register_namespace

(This may be a documentation issue -- in any case, this may be helpful to someone else)

EDIT
I see this problem is mentioned in issue #2, but I didn't make the connection until after creating this issue.

I encountered a problem where Chrome refused to upgrade the connection, due to multiple CORS header being returned in the server response, when using fastapi.CORSMiddleware and setting allowed origins in both places

app = FastAPI()
app.add_middleware(
    CORSMiddleware,
    # allow any origin for development purposes, don't do this in production
    allow_origins=['*'], 
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)
sio = SocketManager(app=app, cors_allowed_origins=['*'])

Seem obvious now, but setting both allow_origins in CORSMiddleware, and cors_allowed_origins in fastapi-socketio causes duplicate headers to be returned to the client (which causes errors in Chrome, and the connection isn't upgraded)

Related to python-socketio issue 205 -- this response recommends async_mode='sanic' and cors_allowed_origins=[] in the constructor:

    engineio.AsyncServer(async_mode='sanic', cors_allowed_origins=[])

I've confirmed that passing cors_allowed_origins=[] in the SocketManager() constructor resolves the issue in this situation.

(See also this issue)

The PIP command appears to work:

$ pip install fastapi-socketio
Collecting fastapi-socketio
  Downloading fastapi_socketio-0.1-py3-none-any.whl (6.0 kB)
Installing collected packages: fastapi-socketio
Successfully installed fastapi-socketio-0.1

But the resulting module is effectively empty:

$ find .../site-packages/fastapi_socketio/
.../site-packages/fastapi_socketio/
.../site-packages/fastapi_socketio/__pycache__
.../site-packages/fastapi_socketio/__pycache__/__init__.cpython-38.pyc
.../site-packages/fastapi_socketio/__init__.py

The __init__py looks like a stub.

$ cat .../site-packages/fastapi_socketio/__init__.py 
def example_function():
    return 1 + 1

Hello! thanks for pretty library!!

I want to talk about my problem and how i do solved it!

If you have a better way or I did something wrong, please make a comment : )

1. Change socketio_path to following your mount_location.

I pretty sure your code will work, if you set mount_location to '/'and touch noting.
And the default mount_location is '/ws'. So you should change your socketio_path as '/ws/socket.io'

This is my think about now situation.
Request('/') -> FastAPI --redirect--> ASGIApp('/') -> SocketIOPath('/socket.io' )

2. When you use postman.

You maybe use Socket.io instead of WebSocket.
But i recommend you to using websocket, Becuase of the path postman automatically direct.

• It miss my /ws path. you can check it below image.

• Below image is example about websocket. You can use like it!

Hello! In #20 you added ability to join and leave rooms, but you made it as properties so when you call
sio.enter_room(sid, room)

it results to

TypeError: enter_room() missing 2 required positional arguments: 'sid' and 'room'

It should be not properties but methods.

There are times when it may be necessary to be able to pass optional arguments to the AsyncServer constructor.

The current SocketManager constructor passes a fixed set of arguments when it initializes the _sio instance.

Perhaps an optional dict argument, socketio_server_args could be passed down into the AsyncServer constructor, as kwargs.

I'll try to work up a PR for this soon.

The default mounting point of /ws/socket.io no longer works correctly for quite some time now, because of this change to Starlette (which, apparently, is just following the ASGI spec): encode/starlette#2413 (reply in thread)

First, you will have noticed that your JavaScript code using socket.io gives lots of 404 errors (or 403 errors, perhaps) and you will have tried to fix them by doing this:

var magicalMysteryOptions = { path: '/ws/socket.io', transports: ['websocket', 'polling', 'flashsocket']};
var conversionSocket = io(magicalMysteryOptions);

But, sadly, now you have another problem, which is a very large stacktrace on the server side with this in it:

RuntimeError: Expected ASGI message 'websocket.accept', 'websocket.close', or 'websocket.http.response.start' but got 'http.response.start'.

You have two choices, either you can downgrade to fastapi==0.108.0 (not recommended), or you can add a socketio_path argument to your SocketManager constructor:

socket_manager = SocketManager(
    app=app,
    socketio_path="/ws/socket.io",
)

This needs to be fixed in fastapi-socketio so that it passes the full path to socket.io (that is, prefixed with the mount location) in the ASGIApp constructor, and then fastapi-socketio needs to depend on at least the versions of FastAPI and Starlette mentioned above.

Since just joining mount_location and socketio_path will conflict with the workaround above, it would probably be a good idea to respect an absolute socketio_path if specified...

shouldn't setup.py declare it's dependencies on :

• fastapi >= ??
• python-socketio >= ???

Would it be possible to create a new release where the following change is included?

a531f49

We need this in order to override the json-parameter in AsyncServer to replace the default Python json module used.

Do I use the same port as my FastAPI server? I have it running on port 8000, this is what my URL looks like when I try to connect

http://localhost:8000/ws/socket.io/

Is that correct, Im using the default setting.

Thanks

I'm just wondering how to get multiple workers working with socketio (this might be an issue with python-socketio, but I'm not sure). I'm currently on 0.0.10 and have the kwargs support, so I've tried using a client_manager like such:

from fastapi_socketio import SocketManager
from socketio import AsyncRedisManager
...
client_manager = AsyncRedisManager('redis://localhost:6379/1')
socket_manager = SocketManager(app=app, client_manager=client_manager)

and executing the server with

$ DEBUG=1 python -m uvicorn main:app --port 9000 --host 0.0.0.0 --workers 4

But when I attach a client to it, I've noticed that the client constantly disconnects and reconnects. In the server log, I'll get:

INFO:     connection closed
INFO:     127.0.0.1:35020 - "POST /socket.io/?EIO=4&transport=polling&t=OjdZ_BE&sid=drxs24MybaAm66dEAAAF HTTP/1.1" 200 OK
INFO:     127.0.0.1:35034 - "GET /socket.io/?EIO=4&transport=polling&t=OjdZ_S3 HTTP/1.1" 200 OK
INFO:     127.0.0.1:35040 - "POST /socket.io/?EIO=4&transport=polling&t=OjdZ_SF&sid=Vfa5Ul5cdE23LNbpAAAD HTTP/1.1" 400 Bad Request
Invalid session Vfa5Ul5cdE23LNbpAAAD (further occurrences of this error will be logged with level INFO)
2023-10-25 08:59:30 kevin-ubuntu engineio.server[182810] ERROR Invalid session Vfa5Ul5cdE23LNbpAAAD (further occurrences of this error will be logged with level INFO)
INFO:     127.0.0.1:35056 - "GET /socket.io/?EIO=4&transport=polling&t=OjdZ_SH&sid=Vfa5Ul5cdE23LNbpAAAD HTTP/1.1" 400 Bad Request
INFO:     ('127.0.0.1', 35066) - "WebSocket /socket.io/?EIO=4&transport=websocket&sid=Vfa5Ul5cdE23LNbpAAAD" [accepted]
INFO:     connection open
INFO:     connection closed
INFO:     127.0.0.1:35074 - "POST /socket.io/?EIO=4&transport=polling&t=OjdZ_SX&sid=Vfa5Ul5cdE23LNbpAAAD HTTP/1.1" 400 Bad Request
INFO:     127.0.0.1:35080 - "GET /socket.io/?EIO=4&transport=polling&t=OjdZ_gT HTTP/1.1" 200 OK
INFO:     127.0.0.1:35094 - "POST /socket.io/?EIO=4&transport=polling&t=OjdZ_gz&sid=Q3nKr2Uz_s2hrSFbAAAG HTTP/1.1" 400 Bad Request
INFO:     127.0.0.1:35116 - "GET /socket.io/?EIO=4&transport=polling&t=OjdZ_h0&sid=Q3nKr2Uz_s2hrSFbAAAG HTTP/1.1" 400 Bad Request
INFO:     ('127.0.0.1', 35108) - "WebSocket /socket.io/?EIO=4&transport=websocket&sid=Q3nKr2Uz_s2hrSFbAAAG" 403
INFO:     connection failed (403 Forbidden)
INFO:     connection closed
INFO:     127.0.0.1:35122 - "POST /socket.io/?EIO=4&transport=polling&t=OjdZ_hG&sid=Q3nKr2Uz_s2hrSFbAAAG HTTP/1.1" 400 Bad Request
INFO:     127.0.0.1:35134 - "GET /socket.io/?EIO=4&transport=polling&t=OjdZ_ra HTTP/1.1" 200 OK
INFO:     127.0.0.1:35148 - "POST /socket.io/?EIO=4&transport=polling&t=OjdZ_sC&sid=zhul5vF4Rxl087nVAAAB HTTP/1.1" 400 Bad Request
INFO:     127.0.0.1:35150 - "GET /socket.io/?EIO=4&transport=polling&t=OjdZ_sF&sid=zhul5vF4Rxl087nVAAAB HTTP/1.1" 400 Bad Request
INFO:     ('127.0.0.1', 35152) - "WebSocket /socket.io/?EIO=4&transport=websocket&sid=zhul5vF4Rxl087nVAAAB" 403

Similarly, on the client side, I'm seeing the connection drop due to the 403.

The @sio.on decorator is not working for me. What am I doing wrong ?

I have an issue connecting to the fastapi-socketio server by a python script. I am running this code:

import socketio


sio = socketio.Client()
sio.connect('http://0.0.0.0:8000')

I also tried with asyncio and i get another error:

import socketio
import asyncio


sio = socketio.AsyncClient()

async def main():
    await sio.connect('http://0.0.0.0:8000')

asyncio.run(main())

So that we can use Redis or RabbitMQ to make socket.io work in a multi process context.

See https://python-socketio.readthedocs.io/en/latest/server.html?highlight=redis#using-a-message-queue

I am trying to run the example app. Only change is port number 8002 in my code.
I see this error when I try to make a WebSocket request to the server from Postman

Error: Unexpected server response: 403
Handshake Details
Request URL: http://localhost:8002/socket.io/?EIO=4&transport=websocket
Request Method: GET
Status Code: 403 Forbidden
Request Headers
Sec-WebSocket-Version: 13
Sec-WebSocket-Key: fKVQf5eYrPb4tfZx6iHFEg==
Connection: Upgrade
Upgrade: websocket
Sec-WebSocket-Extensions: permessage-deflate; client_max_window_bits
Host: localhost:8002
Response Headers
Date: Thu, 22 Dec 2022 04:43:26 GMT
Content-Length: 0
Content-Type: text/plain
Connection: close

How can this be fixed? Appreciate any pointers.

Hello humans,
I faced an issue when I was trying to use fastapi-socketio and the CORSMiddleware

app = FastAPI()
sio = SocketManager(app=app)

# CORS
# Set all CORS enabled origins
if config.BACKEND_CORS_ORIGINS:
    app.add_middleware(
        CORSMiddleware,
        allow_origins=["*"],
        allow_credentials=True,
        allow_methods=["*"],
        allow_headers=["*"],
    )

and this error was showing up

The workaround I found was to set to an empty list the cors_allowed_origins parameter on the SocketManager to prevent the duplication of the values
Solution

app = FastAPI()
sio = SocketManager(app=app, cors_allowed_origins=[])

# CORS
# Set all CORS enabled origins
if config.BACKEND_CORS_ORIGINS:
    app.add_middleware(
        CORSMiddleware,
        allow_origins=["*"],
        allow_credentials=True,
        allow_methods=["*"],
        allow_headers=["*"],
    )

The solution was taken from here

if I have some time, I will try to fix it,
Cheers