在另一个消费者的一个Django Channels消费者中断开循环

Question

I'm building web-app with Django and Django Channels that utilizes websockets.

When user clicks the button in browser, websocket sends data to my server and consumer on the server starts to send messages to the client once per second (in loop).

I want to create another button that will stop this data sending process. When user clicks on this new button, websocket sends another data to server and consumer on the server must somehow stop the loop in previous consumer. Also I will require this to stop the loop when client disconnects.

I felt a desire to use global variable. But Django Channels documentation states that they strongly not recommend to use global variables as they want keep the app network transparent (don't really understand this).

I've tried to use channel session. I made second consumer to update value in channel session, but channel session values didn't get updated in first consumer.

Here is simplified code. Browser:

var socket = new WebSocket("ws://" + window.location.host + "/socket/");
$('#button1').on('click', function() { 
    socket.send(JSON.stringify({action: 'start_getting_values'}))
});
$('#button2').on('click', function() { 
    socket.send(JSON.stringify({action: 'stop_getting_values'}))
});

Consumer on server:

@channel_session
def ws_message(message):
    text = json.loads(message.content['text'])

    if text['action'] == 'start_getting_values':
        while True:
            # Getting some data here
            # ...
            message.reply_channel.send({"text": some_data}, immediately=True)
            time.sleep(1)

    if text['action'] == 'stop_getting_values':
        do_something_to_stop_the_loop_above()

Answer 1

Well, I managed to solve the task myself after I contacted Django Channels developers.

The approach of making loop inside consumer is bad because it will block the site once consumer will be run amount of times equal to amount of threads of all workers running this consumer.

So my approach was the following: once consumer gets 'start_getting_values' signal, it adds current reply channel to a group as well as increments value on Redis server it connected to (I use Redis as channel layer backend but it will work on any other backend).

What value does it increments? On Redis I have a key say 'groups' of hash object type. Each key of this key represents a group in Channels and value represents amount of reply channels in this group.

Then I created a new python file where I connected to same Redis server. In this file I run infinite loop which loads dict from key 'groups' from Redis. Then I loop through each keys in this dict (each key represents Channels groups name) and broadcast the data to each group which have non-zero value. When I run this file, it's run as separate process and thus doesn't block anything on consumer side.

To stop broadcasting to the user, when I get appropriate signal from him, I just remove him from the group as well as decrement appropriate Redis value.

Consumer code:

import redis

redis_client = redis.StrictRedis(host='localhost', port=6379, db=0)

@channel_session_user
def ws_message(message):

    text = json.loads(message.content['text'])

    if text['stream'] == 'start_getting_values':
        value_id = text['value_id']
        redis_client.hincrby('redis_some_key', value_id, 1)
        Group(value_id).add(message.reply_channel)
        channel_session['value_id'] = value_id
        return 0

    if text['stream'] == 'stop_getting_values':
        if message.channel_session['value_id'] != '':
            value_id = message.channel_session['value_id']
            Group(value_id).discard(message.reply_channel)

            l = redis_client.lock(name='del_lock')
            val = redis_client.hincrby('redis_some_key', value_id, -1)
            if (val <= 0):
                redis_client.hdel('redis_some_key', value_id)
            l.release()
        return 0

Separate python file:

import time
import redis
from threading import Thread
import asgi_redis


redis_client = redis.StrictRedis(host='localhost', port=6379, db=0)
cl = asgi_redis.RedisChannelLayer()

def some_action(value_id):

    # getting some data based on value_id
    # ....

    cl.send_group(value_id, {
        "text": some_data,
    })


while True:
    value_ids = redis_client.hgetall('redis_some_key')

    ths = []
    for b_value_id in value_ids.keys():
        value_id = b_value_id.decode("utf-8")
        ths.append(Thread(target=some_action, args=(value_id,)))

    for th in ths:
        th.start()
    for th in ths:
        th.join()


    time.sleep(1)