CODEWITHSUNDEEP
djangowebsocketdjango-channels
aryan
aryan

Reputation: 153

Django Channel Custom Authentication Middleware __call__() missing 2 required positional arguments: 'receive' and 'send'

I am writing a custom authentication middleware for django channels

class TokenAuthMiddleware:
    def __init__(self, inner):
        # Store the ASGI application we were passed
        self.inner = inner

    def __call__(self, scope):

        return TokenAuthMiddlewareInstance(scope, self)


class TokenAuthMiddlewareInstance:

    def __init__(self, scope, middleware):
        self.middleware = middleware
        self.scope = dict(scope)
        self.inner = self.middleware.inner

    async def __call__(self, receive, send):
        ## my logic to get validate user and store the user in user data
        ...
        ...
        ...
        self.scope['user'] = user_data
        inner = self.inner(self.scope)
        return await inner(receive, send)

but on trying to connect to web socket from front end I get the following error

TypeError: __call__() missing 2 required positional arguments: 'receive' and 'send'

Upvotes: 6

Views: 9595

Answers (6)

Yogesh
Yogesh

Reputation: 1

from channels.db import database_sync_to_async
from rest_framework.authtoken.models import Token
from django.contrib.auth.models import AnonymousUser
from urllib.parse import parse_qs
from channels.auth import AuthMiddlewareStack

@database_sync_to_async
def get_user(scope):
    try:
        token_key=parse_qs(scope['query_string'].decode("utf8"))["token"][0]        
        token=Token.objects.get(key=token_key)
        return token.user
    except Token.DoesNotExist:
        return AnonymousUser()
    

class TokenAuthMiddleware:
    def __init__(self,inner):
        self.inner=inner

    def __call__(self,scope):
        return TokenAuthMiddlewareInstance(scope,self)


class TokenAuthMiddlewareInstance:
    def __init__(self,scope,middleware):
        self.middleware = middleware
        self.scope=dict(scope)
        self.inner=self.middleware.inner

    async def __call__(self,receive,send):
        self.scope['user'] = await get_user(self.scope)
        return await self.inner(self.scope,receive,send)
    
TokenAuthMiddlewareStack = lambda inner: TokenAuthMiddleware(AuthMiddlewareStack(inner))

I got an error 2 positional argument missing receive and send

Traceback (most recent call last):
  File "D:\Project\IQ Tester\env\lib\site-packages\channels\staticfiles.py", line 44, in __call__
    return await self.application(scope, receive, send)
  File "D:\Project\IQ Tester\env\lib\site-packages\channels\routing.py", line 71, in __call__
    return await application(scope, receive, send)
  File "D:\Project\IQ Tester\env\lib\site-packages\asgiref\compatibility.py", line 34, in new_application
    return await instance(receive, send)
  File "D:\Project\IQ Tester\backend\account\token_auth_middleware.py", line 40, in __call__ 
    inner=self.inner(self.scope)
TypeError: __call__() missing 2 required positional arguments: 'receive' and 'send'

so to solve this I write this

return await self.inner(self.scope,receive,send)

instead of this

self.scope['user'] = user_data
inner = self.inner(self.scope)
return await inner(receive, send)

Upvotes: 0

Lukasz Dynowski
Lukasz Dynowski

Reputation: 13700

This error happened to me when I installed channels==2.4.0

Updating channels to channels==3.0.3 (latest at the moment) fixed the issue!

Upvotes: 3

Igor Z
Igor Z

Reputation: 631

from urllib.parse import parse_qs

from django.contrib.auth import get_user_model
from django.contrib.auth.models import AnonymousUser
from django.db import close_old_connections

from channels.auth import AuthMiddlewareStack
from rest_framework_simplejwt.tokens import AccessToken

from channels.db import database_sync_to_async

User = get_user_model()


@database_sync_to_async
def get_user(user_id):
    try:
        return User.objects.get(id=user_id)
    except User.DoesNotExist:
        return AnonymousUser()


class TokenAuthMiddleware:
    def __init__(self, inner):
        self.inner = inner

    async def __call__(self, scope, receive, send):
        close_old_connections()
        query_string = parse_qs(scope['query_string'].decode())
        token = query_string.get('token')

        if not token:
            scope['user'] = AnonymousUser()
            return await self.inner(scope, receive, send)

        access_token = AccessToken(token[0])
        user = await get_user(access_token['id'])

        if isinstance(user, AnonymousUser):
            scope['user'] = AnonymousUser()
            return await self.inner(scope, receive, send)

        if not user.is_active:
            scope['user'] = AnonymousUser()
            return await self.inner(scope, receive, send)

        scope['user'] = user
        return await self.inner(scope, receive, send)


TokenAuthMiddlewareStack = lambda inner: TokenAuthMiddleware(AuthMiddlewareStack(inner))

Upvotes: 1

lukatavcer
lukatavcer

Reputation: 31

As Yuva Raja has said, in Django Channels version 3 you need to set your path as:

websocket_urlpatterns = [
    re_path(r'ws/chat/(?P<room_name>\w+)/$', consumers.ChatConsumer.as_asgi()),
]

One more thing, in their Custom authentication official documentation they forgot to use scope instead of self.scope. So be sure to use:

scope['user'] = await get_user(int(scope["query_string"]))

instead of their example:

scope['user'] = await get_user(int(self.scope["query_string"]))

Upvotes: 3

Yuvaraja
Yuvaraja

Reputation: 221

For your reference: https://channels.readthedocs.io/en/stable/releases/3.0.0.html

change from in routing.py

websocket_urlpatterns = [
    re_path(r'ws/chat/(?P<room_name>\w+)/$', consumers.ChatConsumer),
]

to Consumers now have an as_asgi() class method you need to call when setting up your routing:

websocket_urlpatterns = [
    re_path(r'ws/chat/(?P<room_name>\w+)/$', consumers.ChatConsumer.as_asgi()),
]

then if you need custom authentication https://channels.readthedocs.io/en/stable/topics/authentication.html#custom-authentication

from channels.auth import AuthMiddlewareStack
from channels.db import database_sync_to_async
from django.contrib.auth import get_user_model

User = get_user_model()

@database_sync_to_async
def get_user(user_id):
    try:
        return User.objects.get(id=user_id)
    except User.DoesNotExist:
        return AnonymousUser()
        
class QueryAuthMiddleware:
    """
    Custom middleware (insecure) that takes user IDs from the query string.
    """
        
    def __init__(self, app):
        # Store the ASGI application we were passed
        self.app = app
        
    async def __call__(self, scope, receive, send):
        # Look up user from query string (you should also do things like
        # checking if it is a valid user ID, or if scope["user"] is already
        # populated).
        scope['user'] = await get_user(int(scope["query_string"]))
        
        return await self.app(scope, receive, send)
TokenAuthMiddlewareStack = lambda inner: QueryAuthMiddleware(AuthMiddlewareStack(inner))

use requirements.txt as following list, and also download package in this order

Django==3.0.8
djangorestframework==3.11.0
websocket-client==0.57.0
redis==3.5.3
asgiref==3.2.10
channels-redis==2.4.2
channels==3.0.1

Upvotes: 14

tapion
tapion

Reputation: 143

I managed to make it work this way, with Django Channels 3:

from django.contrib.auth.models import AnonymousUser

from rest_framework.authtoken.models import Token

from channels.auth import AuthMiddlewareStack
from channels.db import database_sync_to_async

import urllib.parse

@database_sync_to_async
def get_user(token):
    try:
        token = Token.objects.get(key=token)
        return token.user
    except Token.DoesNotExist:
        return AnonymousUser()

class TokenAuthMiddleware:
    def __init__(self, inner):
        self.inner = inner
    def __call__(self, scope):
        return TokenAuthMiddlewareInstance(scope, self)


class TokenAuthMiddlewareInstance:
    """
    Yeah, this is black magic:
    https://github.com/django/channels/issues/1399
    """
    def __init__(self, scope, middleware):
        self.middleware = middleware
        self.scope = dict(scope)
        self.inner = self.middleware.inner

    async def __call__(self, receive, send):
        decoded_qs = urllib.parse.parse_qs(self.scope["query_string"])
        if b'token' in decoded_qs:
          token = decoded_qs.get(b'token').pop().decode()
          self.scope['user'] = await get_user(token)
        return await self.inner(self.scope, receive, send)


TokenAuthMiddlewareStack = lambda inner: TokenAuthMiddleware(AuthMiddlewareStack(inner))

Upvotes: 3

Related Questions