app_handler_patterns = harvester.get_handler_patterns() app_http_handler_patterns = app_handler_patterns['http_handler_patterns'] app_ws_handler_patterns = app_handler_patterns['ws_handler_patterns'] ws_routing_patterns = [] for namespace, urls in app_ws_patterns.items(): for url in urls: ws_routing_patterns.append(url) http_routing_patterns = [] for namespace, urls in app_http_handler_patterns.items(): for url in urls: http_routing_patterns.append(url) for namespace, urls in app_ws_handler_patterns.items(): for url in urls: ws_routing_patterns.append(url) application = ProtocolTypeRouter({ # 'http' -> django views are added automatically 'websocket': AuthMiddlewareStack(URLRouter(ws_routing_patterns)) }) if http_routing_patterns: http_routing_patterns.append(django_url(r'', AsgiHandler)) application.application_mapping['http'] = AuthMiddlewareStack( URLRouter(http_routing_patterns))
from channels.auth import AuthMiddlewareStack from channels.routing import ProtocolTypeRouter, URLRouter from django.urls import path from channelsApp.chatconsumers import ChatRoomConsumer from channelsApp.consumers import ChatConsumer application = ProtocolTypeRouter({ # (http->django views is added by default) 'websocket': AuthMiddlewareStack( URLRouter([ path('channels/<str:room_name>/', ChatConsumer), path("chat/stream/", ChatRoomConsumer), ])), })
import os from channels.routing import ProtocolTypeRouter, URLRouter from channels.auth import AuthMiddlewareStack from django.core.asgi import get_asgi_application from chat.routing import websocket_urlpatterns os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings") application = ProtocolTypeRouter( { "http": get_asgi_application(), "websocket": AuthMiddlewareStack(URLRouter(websocket_urlpatterns)), } )
""" ASGI config for config 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 django.urls import path from django.core.asgi import get_asgi_application from channels.routing import ProtocolTypeRouter, URLRouter from registros.consumers import CrearConsumer, RegistroConsumer, AlertaConsumer os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings') application = ProtocolTypeRouter({ "http": get_asgi_application(), "websocket": URLRouter([ path('registro/', RegistroConsumer.as_asgi()), path('alerta/', AlertaConsumer.as_asgi()), path('crear/', CrearConsumer.as_asgi()), ]) })
from channels.auth import AuthMiddlewareStack from channels.routing import ProtocolTypeRouter, URLRouter import kafkaApp.routing application = ProtocolTypeRouter({ # (http->django views is added by default) 'websocket': AuthMiddlewareStack(URLRouter(kafkaApp.routing.websocket_urlpatterns)), })
from django.conf.urls import url from channels.routing import ProtocolTypeRouter, URLRouter from channels.auth import AuthMiddlewareStack from tools import web_receptor application = ProtocolTypeRouter({ # WebSocket "websocket": AuthMiddlewareStack( URLRouter([ url(r"^wx/notify/$", web_receptor.Broadcast), ])), })
""" ASGI config for realtime_pr 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.0/howto/deployment/asgi/ """ import os from django.core.asgi import get_asgi_application from channels.routing import ProtocolTypeRouter from channels.routing import URLRouter from channels.auth import AuthMiddlewareStack from integers.routing import ws_urlpatterns os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'realtime_pr.settings') application = ProtocolTypeRouter({ 'http': get_asgi_application(), 'websocket': AuthMiddlewareStack(URLRouter(ws_urlpatterns)) })
from django.urls import path from channels.http import AsgiHandler from channels.routing import ProtocolTypeRouter, URLRouter from channels.auth import AuthMiddlewareStack from ws.views import ws_chat, ws_check_friends application = ProtocolTypeRouter({ # add users and sessions - see http://channels.readthedocs.io/en/latest/topics/authentication.html "websocket": AuthMiddlewareStack( URLRouter([ path("ws/check_user", ws_chat), path("ws/chat_list", ws_check_friends), ]), ), })
from channels.auth import AuthMiddlewareStack from channels.routing import ProtocolTypeRouter, URLRouter from django.conf.urls import url import chat.routing from .channelsmiddleware import TokenAuthMiddleware application = ProtocolTypeRouter({ 'websocket': TokenAuthMiddleware( URLRouter( # url(r"^ws/?$", consumers.LiveChatConsumer), chat.routing.websocket_urlpatterns ) ) })
""" ASGI config for api 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 import django from django.core.asgi import get_asgi_application os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'api.settings') django.setup() django_asgi_app = get_asgi_application() from channels.auth import AuthMiddlewareStack from channels.routing import ProtocolTypeRouter, URLRouter import gameroom.routing application = ProtocolTypeRouter({ "http": django_asgi_app, 'websocket': AuthMiddlewareStack(URLRouter(gameroom.routing.websocket_urlpatterns)) })
import os import django from channels.http import AsgiHandler from channels.routing import ProtocolTypeRouter, URLRouter from notifications import routing as notifications_routing os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'chatire.settings') django.setup() application = ProtocolTypeRouter({ 'http': AsgiHandler(), 'websocket': URLRouter(notifications_routing.websocket_urlpatterns) })
"""Defines the rules for routing of channels messages (websockets) in the whole project.""" from channels.routing import ProtocolTypeRouter, URLRouter import subscription.routing application = ProtocolTypeRouter( {"websocket": URLRouter(subscription.routing.websocket_urlpatterns)} )
""" @author: liyao @contact: [email protected] @time: 2021/4/23 11:06 上午 """ from apps.user.utils.authentication import TokenAuthMiddlewareStack from channels.routing import URLRouter from channels.routing import ProtocolTypeRouter from django.core.asgi import get_asgi_application # from main.urls.websocket import base from apps.user.urls.websocket import base application = ProtocolTypeRouter({ "http": get_asgi_application(), 'websocket': TokenAuthMiddlewareStack(base.websocket_routing), })
from channels.routing import ProtocolTypeRouter, URLRouter from channels.auth import AuthMiddlewareStack from channels.security.websocket import AllowedHostsOriginValidator, OriginValidator from django.conf.urls import url, re_path # or we can use path and re_path from chat.consumers import ChatConsumer application = ProtocolTypeRouter({ # Empty for now (http->django views is added by default) 'websocket': AllowedHostsOriginValidator( AuthMiddlewareStack( URLRouter([ url(r"^messages/(?P<username>[\w.@+-]+)/$", ChatConsumer), ]))) }) # ws://our domain/<username>
from server.token_auth import TokenAuthMiddleware urlpatterns = [ path("admin/", admin.site.urls), # path("graphql/", csrf_exempt(GraphQLView.as_view(graphiql=True))), url(r'^graphql', csrf_exempt(FileUploadGraphQLView.as_view(graphiql=True))), path("gql/", csrf_exempt(GraphQLView.as_view(batch=True))), ] urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT) urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT) application = ProtocolTypeRouter({ "websocket": TokenAuthMiddleware( URLRouter([path('subscriptions', GraphQLSubscriptionConsumer)]), ), }) ############ # from graphene_django.views import GraphQLView # from server.token_auth import TokenAuthMiddleware # from server.channels import GraphQLSubscriptionConsumer # from channels.routing import ProtocolTypeRouter, URLRouter # from channels.http import AsgiHandler # from channels.auth import AuthMiddlewareStack # from django.conf import settings
""" ASGI config for djreactchat 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.0/howto/deployment/asgi/ """ # import os # from django.core.asgi import get_asgi_application # os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'djreactchat.settings') # application = get_asgi_application() import os from channels.routing import ProtocolTypeRouter from django.core.asgi import get_asgi_application os.environ.setdefault("DJANGO_SETTINGS_MODULE", "mysite.settings") application = ProtocolTypeRouter({ "http": get_asgi_application(), # Just HTTP for now. (We can add other protocols later.) })
from channels.auth import AuthMiddlewareStack from channels.security.websocket import AllowedHostsOriginValidator from channels.routing import ProtocolTypeRouter, URLRouter import trackermaps.routing application = ProtocolTypeRouter({ # (http->django views is added by default) 'websocket':AllowedHostsOriginValidator( AuthMiddlewareStack( URLRouter( trackermaps.routing.websocket_urlpatterns ) ), ) })
""" ASGI config for server 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.0/howto/deployment/asgi/ """ import os from django.core.asgi import get_asgi_application from channels.routing import ProtocolTypeRouter os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'server.settings') application = ProtocolTypeRouter({"http": get_asgi_application()})
# envdsys/routing.py from channels.auth import AuthMiddlewareStack from channels.routing import ProtocolTypeRouter, URLRouter import envdaq.routing # import envnet.routing application = ProtocolTypeRouter({ # (http->django views is added by default) "websocket": AuthMiddlewareStack( URLRouter(envdaq.routing.websocket_urlpatterns) # URLRouter(envnet.routing.websocket_urlpatterns) ), })
import os import django django.setup() from django.core.asgi import get_asgi_application from channels.auth import AuthMiddlewareStack from channels.routing import ProtocolTypeRouter, URLRouter from .routing import ws_urlpatterns os.environ.setdefault("DJANGO_SETTINGS_MODULE", "sacado.settings") application = ProtocolTypeRouter({ # Django's ASGI application to handle traditional HTTP requests "http": get_asgi_application(), # WebSocket handler "websocket": AuthMiddlewareStack(URLRouter(ws_urlpatterns)) })
from channels.routing import ProtocolTypeRouter, URLRouter from django.urls import path from channels.auth import AuthMiddlewareStack from channels.security.websocket import AllowedHostsOriginValidator, OriginValidator from Messenger.consumers import ChatConsumer application = ProtocolTypeRouter({ # Empty for now (http->django views is added by default) 'websocket': AllowedHostsOriginValidator( AuthMiddlewareStack(URLRouter([ path('home/<phone>/', ChatConsumer), ]))) })
# mysite/routing.py from channels.auth import AuthMiddlewareStack from channels.routing import ProtocolTypeRouter, URLRouter import chat.routing application = ProtocolTypeRouter({ # (http->django views is added by default) #'http':search_app, 'websocket': AuthMiddlewareStack(URLRouter(chat.routing.websocket_urlpatterns)), }) ''' 위의 root routing configuration 파일은 클라이언트와 Channels 개발 서버와 연결이 맺어질 때, ProtocolTypeRouter를 가장 먼저 조사하여 어떤 타입의 연결인지 구분합니다. 만약에 WebSocket 연결이라면, 이 연결은 AuthMiddlewareStack으로 이어집니다. AuthMiddlewareStack은 현재 인증된 사용자에 대한 참조로 scope를 결정합니다. ( scope는 나중에 다루도록 하겠습니다. ) 이는 Django에서 현재 인증된 사용자의 view 함수에서 request 요청을 결정하는 AuthenticationMiddleware와 유사한 방식이며, 그 결과 URLRouter로 연결됩니다. URLRouter는 작성한 url 패턴을 기반으로, 특정 소비자의 라우트 연결 HTTP path를 조사합니다. '''
from channels.auth import AuthMiddlewareStack from channels.routing import ProtocolTypeRouter, URLRouter import qua.routing application = ProtocolTypeRouter({ 'websocket': AuthMiddlewareStack(URLRouter(qua.routing.websocket_urlpatterns)), })
from django.core.asgi import get_asgi_application from django.urls import path # new from channels.routing import ProtocolTypeRouter, URLRouter # changed from trips.consumers import TaxiConsumer from taxi.middleware import TokenAuthMiddlewareStack # new application = ProtocolTypeRouter({ 'http': get_asgi_application(), 'websocket': TokenAuthMiddlewareStack( URLRouter([ path('taxi/', TaxiConsumer.as_asgi()), ])), })
For more information on this file, see https://docs.djangoproject.com/en/3.1/howto/deployment/asgi/ """ import os from django.core.asgi import get_asgi_application os.environ.setdefault("DJANGO_SETTINGS_MODULE", "message_project.settings") django_asgi_app = get_asgi_application() from channels.routing import ProtocolTypeRouter, URLRouter from channels.auth import AuthMiddlewareStack import crabsnil_chat.routing # os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'message_project.settings') application = ProtocolTypeRouter({ "http": django_asgi_app, # Just HTTP for now. (We can add other protocols later.) # "websocket": AuthMiddlewareStack( # URLRouter( # crabsnil_chat.routing.websocket_urlpatterns # ) # ) "websocket": crabsnil_chat.routing.websocket_urlpatterns, })
url(r'^create_session/$', consumers.CreateSession), url(r'^create_demo_session/$', consumers.CreateDemoSession), url(r'^delete_sessions/$', consumers.DeleteSessions), url(r'^wait_for_session_in_room/$', consumers.RoomParticipant), url(r'^room_without_session/(?P<room>\w+)/$', consumers.RoomAdmin), url(r'^browser_bots_client/(?P<session_code>\w+)/$', consumers.BrowserBotsLauncher), url(r'^browser_bot_wait/$', consumers.BrowserBot), url( # so it doesn't clash with addon r"^live/$", consumers.LiveConsumer, ), url( # so it doesn't clash with addon r"^otreechat_core/(?P<params>[a-zA-Z0-9_/-]+)/$", consumers.ChatConsumer, ), url(r"^export/$", consumers.ExportData), # for django autoreloader # just so client can detect when server has finished restarting url(r'^no_op/$', consumers.NoOp), ] extensions_modules = get_extensions_modules('routing') for extensions_module in extensions_modules: websocket_routes += getattr(extensions_module, 'websocket_routes', []) application = ProtocolTypeRouter( {"websocket": AuthMiddlewareStack(URLRouter(websocket_routes))})
from channels.routing import ProtocolTypeRouter, URLRouter from channels.auth import AuthMiddlewareStack import notes.routing application = ProtocolTypeRouter({ "websocket": AuthMiddlewareStack(URLRouter(notes.routing.websocket_urlpatterns)), })
from django.conf.urls import url from channels.routing import ProtocolTypeRouter, URLRouter from scoring.views import FightConsumer, FightConsumer2 application = ProtocolTypeRouter({ 'websocket': URLRouter([ url('^/(?P<match_id>\d+)/(?P<fighter_id>\d+)/$', FightConsumer), url('^/(?P<match_id>\d+)/$', FightConsumer2), ]) }) # channel_routing = [ # route('websocket.connect', 'catalog.fight.ws_connect', path=r"^/fight/(?P<match_id>\d+)/(?P<fighter_id>\d+)/$"), # route('websocket.receive', 'catalog.fight.ws_message', path=r"^/fight/(?P<match_id>\d+)/(?P<fighter_id>\d+)/$"), # route('websocket.disconnect', 'catalog.fight.ws_disconnect', path=r"^/fight/(?P<match_id>\d+)/(?P<fighter_id>\d+)/$"), # route('websocket.connect', 'catalog.fight.ws_connect_boss', path=r"^/fight/(?P<match_id>\d+)/$"), # route('websocket.receive', 'catalog.fight.ws_message_boss', path=r"^/fight/(?P<match_id>\d+)/$"), # route('websocket.disconnect', 'catalog.fight.ws_disconnect_boss', path=r"^/fight/(?P<match_id>\d+)/$"), # ] # { # 'websocket.connect': 'channeled.consumers.ws_connect', # 'websocket.receive': 'channeled.consumers.ws_message', # 'websocket.disconnect': 'channeled.consumers.ws_disconnect', # # route('http.request', 'catalog.consumers.http_request_consumer') # }
from channels.auth import AuthMiddlewareStack from channels.routing import ProtocolTypeRouter from channels.security import websocket from django.conf import settings from .consumers import WebsocketConsumer, TokenAuthMiddleware class OriginValidatorThatAllowsFileUrls(websocket.OriginValidator): # We need to allow file urls in the origin header for our cordova app def valid_origin(self, parsed_origin): if parsed_origin is not None and parsed_origin.scheme == 'file': return True return super().valid_origin(parsed_origin) def AllowedHostsAndFileOriginValidator(application): # copied from channels.security.websocket allowed_hosts = settings.ALLOWED_HOSTS if settings.DEBUG and not allowed_hosts: allowed_hosts = ["localhost", "127.0.0.1", "[::1]"] return OriginValidatorThatAllowsFileUrls(application, allowed_hosts) application = ProtocolTypeRouter({ 'websocket': AllowedHostsAndFileOriginValidator( TokenAuthMiddleware(AuthMiddlewareStack(WebsocketConsumer, ), ), ), })
from channels.routing import ProtocolTypeRouter, URLRouter import chat.routing from chat.chatmiddleware import TokenAuthMiddleware application = ProtocolTypeRouter({ 'websocket': TokenAuthMiddleware(URLRouter(chat.routing.websocket_urlpatterns)) })