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):
await close_connections()
query_string = parse_qs(self.scope["query_string"].decode())
token = query_string.get("token")
if not token:
self.scope["user"] = AnonymousUser()
return self.inner(self.scope)
user = await get_user(token)
self.scope["user"] = user
inner = self.inner(self.scope)
return await inner(receive, send)
TokenAuthMiddlewareStack = lambda inner: TokenAuthMiddleware(
AuthMiddlewareStack(inner))
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.security.websocket import AllowedHostsOriginValidator
from django.core.asgi import get_asgi_application
from django.urls import path
from django_loci.channels.base import location_broadcast_path
from django_loci.channels.consumers import LocationBroadcast
channel_routing = ProtocolTypeRouter({
'websocket':
AllowedHostsOriginValidator(
AuthMiddlewareStack(
URLRouter([
path(
location_broadcast_path,
LocationBroadcast.as_asgi(),
name='LocationChannel',
)
]))),
'http':
get_asgi_application(),
})
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
import ws.routing
application = ProtocolTypeRouter({
# (http->django views is added by default)
'websocket':
AuthMiddlewareStack(URLRouter(ws.routing.websocket_urlpatterns)),
})
'''
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
from channels.http import AsgiHandler
from django.conf.urls import url
from .consumers import MessageConsumer, PokePipeConsumer
from .util import pipe_ws_endpoint_name, http_endpoint, http_poke_endpoint_enabled
# TODO document this and discuss embedding with other routes
http_routes = []
if http_poke_endpoint_enabled():
http_routes.append(url(http_endpoint("poke"), PokePipeConsumer))
http_routes.append(url(
"^", AsgiHandler)) # AsgiHandler is 'the normal Django view handlers'
application = ProtocolTypeRouter({
'websocket':
AuthMiddlewareStack(
URLRouter([
url(pipe_ws_endpoint_name(), MessageConsumer),
])),
'http':
AuthMiddlewareStack(URLRouter(http_routes)),
})
from django.conf.urls import urls
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
from channels.security.websocket import AlloweHostOriginValidator, OriginValidator
from chat.consumers import ChatConsumer
application = ProtocolTypeRouter({
'websocket':
AlloweHostOriginValidator(
AuthMiddlewareStack(
URLRouter([url(r"^(?P<username>[\w.@+-]+)", ChatConsumer)])))
})
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter, ChannelNameRouter
import ffxivbot.consumers as consumers
from django.conf.urls import url
application = ProtocolTypeRouter({
# (http->django views is added by default)
'websocket':
AuthMiddlewareStack(
URLRouter([
# url(r'^ws_api', consumers.APIConsumer),
# url(r'^ws_event', consumers.EventConsumer),
url(r'^ws(?!_)', consumers.WSConsumer),
]))
})
"""
ASGI config for CHAT_PROJECT project.
It exposes the ASGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/3.1/howto/deployment/asgi/
"""
import os
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from django.core.asgi import get_asgi_application
import chat.routing
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'final.settings')
application = ProtocolTypeRouter({
"http": get_asgi_application(),
"websocket": AuthMiddlewareStack(
URLRouter(
chat.routing.websocket_urlpatterns
)
),
})
from django.urls import path
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
from channels.security.websocket import AllowedHostsOriginValidator, OriginValidator
from home.consumer import Chatconsumer
application = ProtocolTypeRouter({
'websocket':
AllowedHostsOriginValidator(
AuthMiddlewareStack(URLRouter([
path('home/', Chatconsumer),
])))
})
# -*- coding: utf-8 -*-
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from django.conf.urls import url
from . import consumers
application = ProtocolTypeRouter({
'websocket':
AuthMiddlewareStack(
URLRouter([
url(r'^ws/notify/$', consumers.NotifySubscribeConsumer),
]))
})
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
from channels.security.websocket import AllowedHostsOriginValidator
import chat.routing
import notifier.routing
application=ProtocolTypeRouter({
'websocket':AllowedHostsOriginValidator(
AuthMiddlewareStack(
URLRouter(
chat.routing.websocket_urlpatterns+\
notifier.routing.websocket_urlpatterns
)
)
)
})
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
from django.urls import path
from firstPage import consumer
websocket_urlPattern = path('ws/polData/', consumer.DashConsumer)
application = ProtocolTypeRouter(
{'websocket': AuthMiddlewareStack(URLRouter([websocket_urlPattern]))})
#
#
# application=ProtocolTypeRouter({
# # 'http':
# 'websocket':AuthMiddlewareStack(URLRouter(websocket_urlPattern))
#
# })
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
import audio_player.routing
application = ProtocolTypeRouter({
# (http->django views is added by default)
'websocket':
AuthMiddlewareStack(URLRouter(audio_player.routing.websocket_urlpatterns)),
})
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
import buggernaut.routing
application = ProtocolTypeRouter({
'websocket':
AuthMiddlewareStack(URLRouter(buggernaut.routing.websocket_urlpatterns))
})
if token_name.startswith("JWT"):
try:
user_jwt = jwt.decode(
token_key,
settings.SECRET_KEY,
)
scope["user"] = User.objects.get(id=user_jwt["user_id"])
except (InvalidSignatureError, KeyError, ExpiredSignatureError,
DecodeError, ObjectDoesNotExist):
traceback.print_exc()
return self.inner(scope)
TokenAuthMiddlewareStack = lambda inner: TokenAuthMiddleware(
AuthMiddlewareStack(inner))
if apps.is_installed("django.contrib.auth"):
from channels.auth import AuthMiddlewareStack
else:
AuthMiddlewareStack = None
websocket_urlpatterns = [path("subscriptions", GraphQLSubscriptionConsumer)]
application = ProtocolTypeRouter(
{"websocket": URLRouter(websocket_urlpatterns)})
session_application = ProtocolTypeRouter(
{"websocket": TokenAuthMiddlewareStack(URLRouter(websocket_urlpatterns))})
if AuthMiddlewareStack:
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
import lamegames
from lamegames import urls
application = ProtocolTypeRouter({
# (http->django views is added by default)
'websocket': AuthMiddlewareStack(
URLRouter(
lamegames.urls.websocket_urlpatterns
)
),
})
import os
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from django.conf.urls import url
from django.core.asgi import get_asgi_application
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "myproject.settings")
django_asgi_app = get_asgi_application()
# from social.routing import websockets_urls
import chat.routing
application = ProtocolTypeRouter({
# Django's ASGI application to handle traditional HTTP requests
"http":
django_asgi_app,
# WebSocket chat handler
"websocket":
AuthMiddlewareStack(
URLRouter(
# websockets_urls
chat.routing.websocket_urlpatterns)),
})
import os
from channels.routing import ProtocolTypeRouter, URLRouter
from django.core.asgi import get_asgi_application
from channels.auth import AuthMiddlewareStack
import api_backend.routing
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'mc_backend.settings')
application = ProtocolTypeRouter({
"http": get_asgi_application(),
'websocket': AuthMiddlewareStack(
URLRouter(
api_backend.routing.websocket_urlpatterns
)
)
})
from django.conf.urls import url
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
from user.consumers import ChatConsumer, FriendListConsumer
application = ProtocolTypeRouter({
# WebSocket chat handler
"websocket":
AuthMiddlewareStack(
URLRouter([
url("^message/(?P<message_id>[^/]+)/$", ChatConsumer),
url("^friendList/(?P<user_id>[^/]+)/$", FriendListConsumer),
])),
})
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
import songs.routing
application = ProtocolTypeRouter({
'websocket': AuthMiddlewareStack(URLRouter(songs.routing.websocket_urlpatterns))
})
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.staticfiles import StaticFilesHandler
from channels.http import AsgiHandler
from django.conf.urls import url
from vpnathome.consumers import ProcessRunnerConsumer
from vpnathome.utils import is_database_migrated
__ws_router = URLRouter([
url(r"^ws/$", ProcessRunnerConsumer),
])
__http_router = URLRouter(
[url(r"/static/", StaticFilesHandler),
url(r"", AsgiHandler)])
if is_database_migrated():
application = ProtocolTypeRouter({
"websocket":
AuthMiddlewareStack(__ws_router),
"http":
AuthMiddlewareStack(__http_router),
})
else:
application = ProtocolTypeRouter({"http": __http_router})
def JWTOrTokenAuthMiddlewareStack(inner):
return JWTOrTokenAuthMiddleware(AuthMiddlewareStack(inner))
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
import example_channels.routing
application = ProtocolTypeRouter({
# (http->django views is added by default)
'websocket':
AuthMiddlewareStack(
URLRouter(example_channels.routing.websocket_urlpatterns)),
})
"""
ASGI config for backend project.
It exposes the ASGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/3.1/howto/deployment/asgi/
"""
import os
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from django.core.asgi import get_asgi_application
from backend.urls import websocket_urlpatterns
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'backend.settings')
# application = get_asgi_application()
application = ProtocolTypeRouter({
'http': get_asgi_application(),
'websocket': AuthMiddlewareStack(
URLRouter(
websocket_urlpatterns
)
),
})
import os
from channels.routing import ProtocolTypeRouter, URLRouter
from django.core.asgi import get_asgi_application
from channels.auth import AuthMiddlewareStack
from django.urls import path
from chat.consumers import *
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'mysite.settings')
application = ProtocolTypeRouter({
"http":
get_asgi_application(),
"websocket":
AuthMiddlewareStack(
URLRouter([path('ws/chat/<int:room_name>/', ChatConsumer.as_asgi())]))
})
from channels.routing import ProtocolTypeRouter, URLRouter
from django.urls import path
from django.conf.urls import url
from channels.auth import AuthMiddlewareStack
from channels.security.websocket import AllowedHostsOriginValidator, OriginValidator
from chat import consumers
application = ProtocolTypeRouter({
# Empty for now (http->django views is added by default)
'websocket':
AllowedHostsOriginValidator(
AuthMiddlewareStack(
URLRouter([
path("chat/<username>", consumers.ChatConsumer),
])), ),
})
# mysite/routing.py
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
import chatroom.routing
application = ProtocolTypeRouter({
# (http->django views is added by default)
'websocket': AuthMiddlewareStack(
URLRouter(
chatroom.routing.websocket_urlpatterns
)
),
})
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
import tworaven_apps.websocket_views.routing
application = ProtocolTypeRouter({
# (http->django views is added by default)
'websocket':
AuthMiddlewareStack(
URLRouter(
tworaven_apps.websocket_views.routing.websocket_urlpatterns)),
})
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
import app.routing
application = ProtocolTypeRouter({
'websocket':
AuthMiddlewareStack(URLRouter(app.routing.websock_urlpatterns))
})
"""
ASGI config for snakesite project.
It exposes the ASGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/3.2/howto/deployment/asgi/
"""
import os
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from django.core.asgi import get_asgi_application
import workflow.routing
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "snakesite.settings")
application = ProtocolTypeRouter(
{
"http": get_asgi_application(),
"websocket": AuthMiddlewareStack(
URLRouter(workflow.routing.websocket_urlpatterns)
),
}
)
from django.conf.urls import url
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
from channels.http import AsgiHandler
from consumer.long_long_consumer import LongLongConsumer, CommandConsumer, SomeHttpConsumer
application = ProtocolTypeRouter({
"websocket": AuthMiddlewareStack(
URLRouter([
url(r'^observe/(?P<stream>normal|error)/(?P<oid>[0-9]+)$', LongLongConsumer),
url(r'^command', CommandConsumer),
])
),
"http": AuthMiddlewareStack(
URLRouter([
url(r'', AsgiHandler)
])
)
})
