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))
})
