Client -> Server messages working, but not Server -> Client

[Culpable]

Hey, thank you for taking the time to read this.

I've been experiencing an issue where messages emitted from my server using Flask-SocketIO aren't being received by the client side. I've spent the last couple of days troubleshooting and I'm a bit stuck, so I'm hoping someone can point me in the right direction.

The specific problems I'm facing are:

1. The 'Client connected' message is not printed on the server side when a client connects.
2. No messages seem to be received on the frontend, despite being emitted from the server.

I've tried several steps to resolve the issue:

1. Switching from eventlet to gevent.
2. Running the app directly in python.
3. Running the app using gunicorn and gevent.

Despite these changes, the problem still persists.

I've tried to keep the information contained in the files below to only what is potentially relevant to my issue.

I'm running Python 3.9.16 with the following (potentially) relevant dependencies:

eventlet==0.33.3
Flask==1.1.2
Flask-Login==0.5.0
Flask-Mail==0.9.1
Flask-Migrate==4.0.4
Flask-SocketIO==5.3.5
Flask-SQLAlchemy==2.4.4
Flask-WTF==0.14.3
gevent==23.7.0
gevent-websocket==0.10.1
gunicorn==21.2.0
greenlet==2.0.2
python-socketio==5.8.0

(note that I was having issues with eventlet so swapped to gevent).

In __init__.py:

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_mail import Mail
from flask_socketio import SocketIO
from dotenv import load_dotenv
load_dotenv()

db = SQLAlchemy(metadata=metadata)  # Assign your naming convention to your db instance
migrate = Migrate()
mail = Mail()
socketio = SocketIO(logger=True, engineio_logger=True, async_mode='gevent')

def create_app():
    app = Flask(__name__)
    
    [...]
    
    db.init_app(app)
    mail.init_app(app)
    socketio.init_app(app)
    
    from . import models
    from . import forms
    from . import main_app
    app.register_blueprint(main_app.bp)

    return app

And within main_app.py:

from flask_socketio import send, emit, join_room

[...] 
# Local application imports
from main_app import db, mail, socketio

bp = Blueprint('main_app', __name__)

[...] 

@socketio.on('connect')
def on_connect():
    print('Client connected')
    # Send a test message to the frontend
    msg={'data' : 'hello!'}
    emit('my response', msg)
    # Wait for the client to emit a message, then send a response

@socketio.on_error()        # Handles the default namespace
def error_handler(e):
    print(f"Socket error: {e}")
    pass

@socketio.on('my event')
def handle_message(data):
    print('received event: ' + data)

@socketio.on('message')
def handle_message(data):
    print('received message: ' + data)

(just trying to catch anything from the frontend).

Lastly, on the frontend:

<script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.0.1/socket.io.js"
  integrity="sha512-q/dWJ3kcmjBLU4Qc47E4A9kTB4m3wuTY7vkFJDTZKjTs8jhyGQnaUrxa0Ytd0ssMZhbNua9hE+E7Qv1j+DyZwA=="
  crossorigin="anonymous"></script>
<script>
    $(document).ready(function () {
      var socket = io();
      socket.on('connect', function () {
        console.log("Socket connected");
        socket.emit('my event', { data: 'I\'m connected!' });
      });

      // Capture message 'summary' from the server
      socket.on('my response', function (msg) {
        console.log('Received my response event');
        console.log(msg)
      });
      
      socket.on('message', function (msg) {
        console.log('Received a message from the server:', msg);
      });

    });
</script>

In reading the documentation, it notes that:

The flask run command introduced in Flask 0.11 can be used to start a Flask-SocketIO development server based on Werkzeug, but this method of starting the Flask-SocketIO server is not recommended due to lack of WebSocket support.

Since flask run was my typical way of running the app locally, I had to adapt to this.

I tried two options:

1. Run the app directly in python.
2. Run the app using gunicorn and gevent via gunicorn -k geventwebsocket.gunicorn.workers.GeventWebSocketWorker -w 1 main_app:'create_app()'

For (1), I first had to reconfigure the direct running of the app to avoid circular imports.

To keep flask run running as-is, as well as my Heroku Procfile as web: flask db upgrade; gunicorn main_app:'create_app()', I created a new run.py` file in the project root directory, as below:

import sys
from main_app import create_app, socketio

app = create_app()
port = int(sys.argv[1]) if len(sys.argv) > 1 else 8000

if __name__ == "__main__":
    socketio.run(app, port=port)

(note that this defaults to port 8000 for simplicity, due to using this port in authentication callbacks).

Now when I run python run.py, the app (seemingly) runs as it would if I used flask run - except now, hopefully, it supports Web Sockets.

Here's the terminal logs:

python run.py    
Server initialized for gevent.
Server initialized for gevent.
pK9u41eER83ROCixAAAA: Sending packet OPEN data {'sid': 'pK9u41eER83ROCixAAAA', 'upgrades': ['websocket'], 'pingTimeout': 20000, 'pingInterval': 25000}
pK9u41eER83ROCixAAAA: Received packet MESSAGE data 0
pK9u41eER83ROCixAAAA: Sending packet MESSAGE data 0{"sid":"_Uq7tzEjaIwvY_dtAAAB"}
pK9u41eER83ROCixAAAA: Received request to upgrade to websocket
pK9u41eER83ROCixAAAA: Upgrade to websocket successful
pK9u41eER83ROCixAAAA: Received packet MESSAGE data 2["my event",{"data":"I'm connected!"}]
received event "my event" from _Uq7tzEjaIwvY_dtAAAB [/]
K5E-Ib6BS8l_Xb8jAAAC: Sending packet OPEN data {'sid': 'K5E-Ib6BS8l_Xb8jAAAC', 'upgrades': ['websocket'], 'pingTimeout': 20000, 'pingInterval': 25000}
K5E-Ib6BS8l_Xb8jAAAC: Received packet MESSAGE data 0
K5E-Ib6BS8l_Xb8jAAAC: Sending packet MESSAGE data 0{"sid":"yudf3P_5n6cTsEEDAAAD"}
K5E-Ib6BS8l_Xb8jAAAC: Received request to upgrade to websocket
K5E-Ib6BS8l_Xb8jAAAC: Received packet MESSAGE data 2["my event",{"data":"I'm connected!"}]
received event "my event" from yudf3P_5n6cTsEEDAAAD [/]
K5E-Ib6BS8l_Xb8jAAAC: Upgrade to websocket successful
K5E-Ib6BS8l_Xb8jAAAC: Sending packet PING data None
K5E-Ib6BS8l_Xb8jAAAC: Received packet PONG data 

The browser only logs 'Socket connected', and nothing else.

To be clear, here is what I'm expecting to happen:

1. On the server side, when a client successfully connects to the server, I expect to see the 'Client connected' message being printed on the server console. However, this is not currently happening.

2. On the client side, I expect to see 'Socket connected' (which I do) and a subsequent message logged, "Received my response event" with data payload as soon as the socket connection is established. This is due to the fact that on connection, I'm emitting a 'my response' message from the server. Despite this, I don't see any message logged in the console apart from 'Socket connected'.

3. Furthermore, I added socketio.emit('my response', {'data': 'Connected!'}) to my index view in an attempt to have another message sent to the client as soon as the index route is accessed. I expected to see "Received my response event" with a data payload on the client-side console when accessing the index route, but nothing is logged.

In summary, my main question is: Why are the messages sent from my server using Flask-SocketIO not being received on the client side? And, why isn't the 'Client connected' message being printed on the server-side console when a client successfully connects?

I appreciate any insight or suggestions on how to troubleshoot this issue further.

Thank you very much for taking the time to read this.

[miguelgrinberg]

Your logs show the "Server initialized for gevent" line twice. This suggests to me that you have two SocketIO objects, not just one. If my guess is correct, then I can continue guessing and say that your handlers in the server are not invoked because they are set on the "other" SocketIO object, not the one that is linked to the web server.

[Culpable]

Thank you for your response Miguel; good pickup.

I tried commenting out this line in my __init__.py file:

socketio = SocketIO(logger=True, engineio_logger=True, async_mode='gevent')

To see if there was another socketio somewhere in the file (even though I couldn't find any other instance of socketio or SocketIO in __init__.py or main_app.py using Ctrl + F).

Then when running python run.py, I get:

ImportError: cannot import name 'socketio' from 'main_app' (/project-folder/main_app/__init__.py)
)

Which suggests to me that if there is another socketio somewhere, then perhaps it's somewhere else?

Is there any other way to test this?

[miguelgrinberg]

Here is another idea. Right after your create your socketio object, add a print statement:

socketio = SocketIO(logger=True, engineio_logger=True, async_mode='gevent')
print(socketio)

Then tell me if you see one print or two. If you see two, then that's the problem and we can discuss further. If you see one, then please share the new logs with the two "Server initialized for gevent" lines and the print in the order they appeared.

Also, to avoid external things that can add confusion, make sure you do not use Flask's debug mode.

[Culpable]

Thanks Miguel.

Running python run.py I now get:

<flask_socketio.SocketIO object at 0x104245280>
Server initialized for gevent.
Server initialized for gevent.
GAd99L3rKn4plydfAAAA: Sending packet OPEN data {'sid': 'GAd99L3rKn4plydfAAAA', 'upgrades': ['websocket'], 'pingTimeout': 20000, 'pingInterval': 25000}
GAd99L3rKn4plydfAAAA: Received packet MESSAGE data 0
GAd99L3rKn4plydfAAAA: Sending packet MESSAGE data 0{"sid":"GycuB7BZk3CF2QNYAAAB"}
GAd99L3rKn4plydfAAAA: Received request to upgrade to websocket
GAd99L3rKn4plydfAAAA: Received packet MESSAGE data 2["my event",{"data":"I'm connected!"}]
received event "my event" from GycuB7BZk3CF2QNYAAAB [/]
GAd99L3rKn4plydfAAAA: Upgrade to websocket successful

And (if it helps) gunicorn -k geventwebsocket.gunicorn.workers.GeventWebSocketWorker -w 1 main_app:'create_app()':

[2023-07-30 11:01:51 +0800] [81986] [INFO] Starting gunicorn 21.2.0
[2023-07-30 11:01:51 +0800] [81986] [INFO] Listening at: http://127.0.0.1:8000 (81986)
[2023-07-30 11:01:51 +0800] [81986] [INFO] Using worker: geventwebsocket.gunicorn.workers.GeventWebSocketWorker
[2023-07-30 11:01:51 +0800] [81987] [INFO] Booting worker with pid: 81987
<flask_socketio.SocketIO object at 0x103c795e0>
Server initialized for gevent.
Server initialized for gevent.
w9KoRkJRpkKoCbJSAAAA: Sending packet OPEN data {'sid': 'w9KoRkJRpkKoCbJSAAAA', 'upgrades': ['websocket'], 'pingTimeout': 20000, 'pingInterval': 25000}
w9KoRkJRpkKoCbJSAAAA: Received packet MESSAGE data 0
w9KoRkJRpkKoCbJSAAAA: Sending packet MESSAGE data 0{"sid":"rR9LBoVbOI4sapphAAAB"}
w9KoRkJRpkKoCbJSAAAA: Received request to upgrade to websocket
w9KoRkJRpkKoCbJSAAAA: Received packet MESSAGE data 2["my event",{"data":"I'm connected!"}]
received event "my event" from rR9LBoVbOI4sapphAAAB [/]
w9KoRkJRpkKoCbJSAAAA: Upgrade to websocket successful

So still two print statements.

Also, to avoid external things that can add confusion, make sure you do not use Flask's debug mode.

Apologies - I did not think I was in flask's debug mode when running the two commands above. If I am, apologies for my ignorance, and please point me to where I can correct this.

Note that in addition to the above, I also tried adding some other print statements to help debug this:

1. A print(socketio) in my main flask entry point main_app.py just above the @socketio.on('connect').
2. A print("Below where @socketio.on listeners are defined in main_app.py") just below @socketio.on definitions.
3. A print message before and after socketio.run(app, port=port) in run.py.

So now in main_app.py:

from flask_socketio import send, emit, join_room

[...] 
# Local application imports
from main_app import db, mail, socketio

bp = Blueprint('main_app', __name__)

[...] 

print(socketio)

@socketio.on('connect')
def on_connect():
    print('Client connected')
    # Send a test message to the frontend
    msg={'data' : 'hello!'}
    emit('my response', msg)

@socketio.on_error()        # Handles the default namespace
def error_handler(e):
    print(f"Socket error: {e}")
    pass

@socketio.on('my event')
def handle_message(data):
    print('received event: ' + data)

@socketio.on('message')
def handle_message(data):
    print('received message: ' + data)

print("Below where @socketio.on listeners are defined in main_app.py")

And in run.py:

import sys
from main_app import create_app, socketio

app = create_app()
port = int(sys.argv[1]) if len(sys.argv) > 1 else 8000

if __name__ == "__main__":
    print("Above the socketio.run(app, port=port) line in run.py")
    socketio.run(app, port=port)
    print("Below the socketio.run(app, port=port) line in run.py")

Then running python run.py:

<flask_socketio.SocketIO object at 0x10693a8e0>
Server initialized for gevent.
<flask_socketio.SocketIO object at 0x10693a8e0>
Below where @socketio.on listeners are defined in main_app.py
Server initialized for gevent.
Above the socketio.run(app, port=port) line in run.py
ireiYhZ5JNpUZcztAAAA: Sending packet OPEN data {'sid': 'ireiYhZ5JNpUZcztAAAA', 'upgrades': ['websocket'], 'pingTimeout': 20000, 'pingInterval': 25000}
ireiYhZ5JNpUZcztAAAA: Received packet MESSAGE data 0
ireiYhZ5JNpUZcztAAAA: Sending packet MESSAGE data 0{"sid":"lXORJyyZMcOq5TtoAAAB"}
ireiYhZ5JNpUZcztAAAA: Received request to upgrade to websocket
ireiYhZ5JNpUZcztAAAA: Upgrade to websocket successful
ireiYhZ5JNpUZcztAAAA: Received packet MESSAGE data 2["my event",{"data":"I'm connected!"}]
received event "my event" from lXORJyyZMcOq5TtoAAAB [/]
K3wb9y2ZURwMbkGcAAAC: Sending packet OPEN data {'sid': 'K3wb9y2ZURwMbkGcAAAC', 'upgrades': ['websocket'], 'pingTimeout': 20000, 'pingInterval': 25000}
K3wb9y2ZURwMbkGcAAAC: Received packet MESSAGE data 0
K3wb9y2ZURwMbkGcAAAC: Sending packet MESSAGE data 0{"sid":"CyFGn3ZewA75R8R4AAAD"}
K3wb9y2ZURwMbkGcAAAC: Received request to upgrade to websocket
K3wb9y2ZURwMbkGcAAAC: Upgrade to websocket successful

This seems to confirm that it's the same object, and can perhaps help identify where the second "Server initialized for gevent." is coming from.

Lastly, if it helps, I've also tried:

1. Upgrading to latest version of socket.io.min.js (https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.7.1/socket.io.min.js).
2. Adding cors_allowed_origins="*" (desperation).

Neither option worked, so I reverted both changes.

Thank you again for your time Miguel.

p.s. sorry, I meant to post this in flask-socketio. I had both tabs open :(

[miguelgrinberg]

So still two print statements.

I see only one print statement, and two "Server initialized" entries in your log. The idea here was to check if the same code was running twice, or if you have two SocketIO objects in different places. Based on the results it seems you have two SocketIO objects. So your task is to find where is the other one, the one that does not have a corresponding print statement.

Apologies - I did not think I was in flask's debug mode when running the two commands above.

I did not imply that you were. I just asked you to make sure you are not, because the debugger starts two processes and that could confuse things, as two processes would certainly cause two SocketIO objects to be created. But great, you are not doing this so we do not need to be concerned.

I think at thsi point what I'm going to suggest is that you create a small and complete version of your application and give it to me for debugging (confirming that it still reproduces your issue, of course). I can continue suggesting things to test, but the back and forth is going to delay things. I'll try the app here and let you know what the problem is.

[Culpable]

I see only one print statement, and two "Server initialized" entries in your log

Sorry, that was a typo. As you mention, I meant to say there were still two "Server initialized" entries.

The idea here was to check if the same code was running twice, or if you have two SocketIO objects in different places.

Yes, that makes sense. I tried to further this line of troubleshooting at the end of my last reply.

I thought the last code block where the print statement in the __init__.py file and main_app.py flask entry point print(socketio) yielding <flask_socketio.SocketIO object at 0x10693a8e0> meant that they were referring to the same object.

I did not imply that you were. I just asked you to make sure you are not, because the debugger starts two processes and that could confuse things, as two processes would certainly cause two SocketIO objects to be created.

All good - I'm still fairly new to this, so I like to err on the side of naivete.

I think at this point what I'm going to suggest is that you create a small and complete version of your application and give it to me for debugging (confirming that it still reproduces your issue, of course).

Sure, if that will make things easier.

Now... to copy/paste the app without breaking everything I love... one moment 🙃

[Culpable]

Okay, after (a lot) more troubleshooting, I think I've got a lead onto what the issue might be.

Your hunch was right: this seems to be related to two SocketIO objects in different places.

But how these two SocketIO objects are coming into existence, I'm not 100% sure.

So in my app, I have a redis worker in a worker.py file.

I didn't think it was relevant to my OP, since (a) I wasn't calling the worker and (b) the worker wasn't even running.

Nevertheless, I think it is relevant.

Here is the worker.py file:

import sys
import os
from rq import Worker, Queue, Connection
from dotenv import load_dotenv
load_dotenv()

# Add the path of the project directory to the PYTHONPATH
project_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
sys.path.insert(0, project_path)

from main_app import create_app 

# Setting up the application context for the worker
app = create_app()
app.app_context().push()
conn = app.redis

listen = ['high', 'default', 'low', 'app-tasks']

if __name__ == '__main__':
    with Connection(conn):
        worker = Worker(map(Queue, listen))
        worker.work()

And in main_app.py:

from rq import Queue
from main_app.worker import conn

q = Queue(connection=conn)

In the above, I found that I needed to set up the application context for the worker since the worker accesses the database.
When I commented out:

# from main_app.worker import conn

# q = Queue(connection=conn)

And removed all of the previous print statements used for troubleshooting,

And ran python run.py, I got this on the backend:

Server initialized for gevent.
DpJkJfR8mtRmtjVdAAAA: Sending packet OPEN data {'sid': 'DpJkJfR8mtRmtjVdAAAA', 'upgrades': ['websocket'], 'pingTimeout': 20000, 'pingInterval': 25000}
DpJkJfR8mtRmtjVdAAAA: Received packet MESSAGE data 0
Client connected
emitting event "my response" to yp7_ZjyQqn0CkduwAAAB [/]
DpJkJfR8mtRmtjVdAAAA: Sending packet MESSAGE data 2["my response",{"data":"Connected!"}]
DpJkJfR8mtRmtjVdAAAA: Sending packet MESSAGE data 0{"sid":"yp7_ZjyQqn0CkduwAAAB"}
DpJkJfR8mtRmtjVdAAAA: Received request to upgrade to websocket
DpJkJfR8mtRmtjVdAAAA: Received packet MESSAGE data 2["my event",{"data":"I'm connected!"}]
received event "my event" from yp7_ZjyQqn0CkduwAAAB [/]
received event: {'data': "I'm connected!"}
DpJkJfR8mtRmtjVdAAAA: Upgrade to websocket successful

And on the frontend:

Socket connected
chat:893 Received my response event
chat:894 {data: 'Connected!'}

Woo hoo! Progress!

So if I understand this correctly:

1. When I import the connection from worker.py in my main_app.py file, I am running the line app = create_app() in worker.py. This is because Python runs the code in a module file when it is imported—even though worker.py was never explicitly run.
2. This execution of create_app() function leads to another SocketIO instance being created in the application context. This is because I am creating the socketio instance in my __init__.py file, which is part of the application initialization through the create_app() function.
3. Therefore, when main_app.py is run, it ends up having two SocketIO instances - one from its own initialization and one from importing the connection from worker.py.
4. The two instances don't share state, including registered event handlers. So, when I register my handlers (e.g., 'connect', 'disconnect', 'my event') in main_app.py, those handlers are registered to the SocketIO instance in the main_app.py, not the one in the worker.py. Therefore, messages from the server (the one in worker.py) do not reach the client because the SocketIO instance that the server is running on does not have any handlers registered.

Okay, presuming I got that right, I have two questions that I'd love your assistance with if you wouldn't mind.
First, my __init__.py file:

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_mail import Mail
from flask_socketio import SocketIO
from dotenv import load_dotenv
load_dotenv()

db = SQLAlchemy(metadata=metadata) 
migrate = Migrate()
mail = Mail()
socketio = SocketIO(logger=True, engineio_logger=True, async_mode='gevent')

def create_app():
    app = Flask(__name__)
    
    [...]

    # Redis
    app.config['REDIS_URL'] = os.getenv('REDIS_URL', 'redis://localhost:6379')
    app.redis = Redis.from_url(app.config['REDIS_URL'])
    app.task_queue = rq.Queue('app-tasks', connection=app.redis)
    db.init_app(app)
    mail.init_app(app)
    socketio.init_app(app)
    
    from . import models
    from . import forms
    from . import main_app
    app.register_blueprint(main_app.bp)

    return app

With my main_app.py and worker.py file shown above.

My questions:
(a) How can I reconfigure my current import structure (I initially took inspiration from your post here, although I think I deviated a little) to facilitate bringing q = Queue(connection=conn) into the main flask entry point main_app.py?

Can/should I just use current_app.task_queue?

EDIT: It seems I can, so long as I call q = current_app.task_queue within my view function, which has the application context.
The issue I'm having is that even though I'm able to call q.enqueue(worker_function), and it executes successfully, the emitted event does not seem to be registered by the frontend.

On the backend it's showing:

emitting event "example" to all [/]

But this isn't being picked up by the frontend:

socket.on('example', function (msg) {
        console.log('Received summary event');
        console.log(msg)
        console.log(msg.summary)
      });

(note that the frontend is still picking up and logging the "Received my response event" event from the backend as previously described).

Is this because I'm yet to set up the dedicated SocketIO instance for the redis worker as you describe here?

(b) Given that my redis worker is actually the one that's going to emit events, should I just adjust the SocketIO initialisation in __init__.py via adding message_queue='redis://'? i.e.

socketio = SocketIO(async_mode='gevent', message_queue='redis://')

Thank you very much for your time Miguel; apologies for my ignorance.

[miguelgrinberg]

Okay, great. So the issue is that you have two Flask applications coexisting in the same process. I was close with my assessment, there's the two apps, both trying to use a single SocketIO object.

The solution is simple. Do not import your worker code into the main application. That code is intended to run separately in the worker process, and should never be imported into the main app. The task queue instance used in the app to submit jobs should be the one created by the main application, not the one created by the code intended for the worker.

[Culpable]

I took your advice on board and moved everything into the worker.py file, and it seems to be working as expected.

This makes a lot more sense. It always felt redundant to me that I was pushing the app context into worker.py... but then passing the app config to the worker function.

Now that the worker function is within worker.py, I no longer have to do this. Thank you Miguel.

One last note: I managed to get the app working with this in my __init__.py file:

from gevent import monkey
monkey.patch_all()

from flask_socketio import SocketIO

redis_url = os.getenv('REDIS_URL', 'redis://localhost:6379')
# Create the SocketIO instance with the relevant parameters and CORS policy
socketio = SocketIO(message_queue=redis_url, async_mode='gevent')

[...]

def create_app():
    app = Flask(__name__)
    
    [...]
    
    # Redis
    app.config['REDIS_URL'] = os.getenv('REDIS_URL', 'redis://localhost:6379')
    app.redis = Redis.from_url(app.config['REDIS_URL'])

And in my worker.py file:

from gevent import monkey
monkey.patch_all()

from flask_socketio import SocketIO

[...]

# Setup SocketIO for worker
socketio_worker = SocketIO(message_queue=app.config['REDIS_URL'], async_mode='gevent')

[...]

my_func():
    [...]
    socketio_worker.emit('event name', {'message': 'my message'})

Is socketio = SocketIO(message_queue=redis_url, async_mode='gevent') in my __init__.py file the wrong way to initalise the web socket server?

While I got the impression from the docs that the message_queue parameter was only needed for the redis worker (i.e. the external process), for some reason the web socket.emit within the worker.py only works if I include the message_queue parameter as part of my __init__.py web socket initialisation.

When I remove it, the browser stops picking up the event.

[note that I'm only emitting web socket events from my Redis worker in this app. Still, I'd like to make sure I get the app architecture right, and properly grasp the concept of socket server initialisation and instances in external processes].

Thank you very much for your time Miguel.

[miguelgrinberg]

You have done it correctly. Both the main server and the worker need to be configured with the queue so that they can communicate.

[Culpable]

Thanks again Miguel, you're the best 💕