from django.conf.urls import include, url
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.http import AsgiHandler
from xmppserver import urls as xmpp_urls, xmpp_server
application = ProtocolTypeRouter({
'http': URLRouter([
url(r'^chat/', include(xmpp_urls.http_urls)),
url(r'', AsgiHandler)
]),
'websocket': URLRouter([
url(r'^chat/', include(xmpp_urls.ws_urls))
])
})
xmpp_server.start_xmpp_server()
import os
from django.core.asgi import get_asgi_application
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
import chatroom.routing
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "edumarker.settings")
application = ProtocolTypeRouter(
{
"http": get_asgi_application(),
"websocket": AuthMiddlewareStack(
URLRouter(chatroom.routing.websocket_urlpatterns)
),
}
)
from channels.routing import ProtocolTypeRouter, URLRouter
from django.urls import path
from notifier.consumers import NoseyConsumer
application = ProtocolTypeRouter(
{"websocket": URLRouter([
path("notifications/", NoseyConsumer),
])})
"""
ASGI config for konfigurationsmanagement_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
import django
from channels.http import AsgiHandler
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
from django.core.asgi import get_asgi_application
import authentication.routing
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'konfigurationsmanagement_backend.settings')
django.setup()
application = ProtocolTypeRouter({
"http": AsgiHandler(),
"websocket": AuthMiddlewareStack(
URLRouter(
authentication.routing.websocket_urlpatterns
)
),
})
#!/usr/bin/env python3
# -*-encoding: utf-8-*-
# Author: Danil Kovalenko
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
from chat.routing import websocket_urlpatterns
application = ProtocolTypeRouter({
'websocket': AuthMiddlewareStack(
URLRouter(
websocket_urlpatterns
)
)
})
from django.conf.urls import url
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
from django.urls import path, include
from viewer import greeter
application = ProtocolTypeRouter({
# WebSocket chat handler
"websocket":
AuthMiddlewareStack(URLRouter([url(r'^viewer/$', greeter)])),
})
from channels.routing import ProtocolTypeRouter, URLRouter
from channels_test import consumers
from django.conf.urls import url
# channel_routing = [
# route("websocket.receive", websocket_receive, path=r"^/chat/"),
# ]
app = ProtocolTypeRouter({
"websocket":
URLRouter([
url(r"^ws/test/$", consumers.BaseConsumer),
]),
})
from django.conf.urls import url
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.security.websocket import AllowedHostsOriginValidator, OriginValidator
from channels.auth import AuthMiddlewareStack
application = ProtocolTypeRouter({
'websocket':
AllowedHostsOriginValidator(AuthMiddlewareStack(URLRouter([])))
})
# Channels imports
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
#from .generic_routing import ProtocolTypeRouter, URLRouter
# WS Ice Imports
from django.conf.urls import url
from . import si_rtc_consumer
# Fetch Django ASGI application early to ensure AppRegistry is populated
# before importing consumers and AuthMiddlewareStack that may import ORM
# models.
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'si_rtc_cli.settings')
#application = get_asgi_application()
si_ws_ice_urlpatterns = [
url(r'^ws_ice/(?P<room_name>[\w]+)/$', si_rtc_consumer.WSTurnConsumer),
]
#turn_urlpatterns = [
# url(r'^turn_ice/(?P<room_name>[\w]+)/$', si_rtc_consumer.WSTurnIceConsumer),
#]
#
application = ProtocolTypeRouter({
# ICE Signaling socket
'websocket':
AuthMiddlewareStack(URLRouter(si_ws_ice_urlpatterns))
})
from channels.auth import AuthMiddlewareStack
from channels.sessions import SessionMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
import chat.routing
application = ProtocolTypeRouter({
'websocket':
SessionMiddlewareStack(URLRouter(chat.routing.websocket_urlpatterns)),
})
from django.urls import path # new
from channels.auth import AuthMiddlewareStack # new
from channels.routing import ProtocolTypeRouter, URLRouter # changed
from .consumers import TaxiConsumer
# changed
application = ProtocolTypeRouter({
'websocket':
AuthMiddlewareStack(URLRouter([
path('taxi/', TaxiConsumer),
]))
})
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
from django.urls import path
from poker.consumers import PokerConsumer
from tables.consumers import MoneyConsumer
application = ProtocolTypeRouter({
# http to views is default
'websocket': AuthMiddlewareStack(URLRouter([
path('ws/user/<str:username>/', MoneyConsumer),
path('ws/tables/<str:pk>/', PokerConsumer),
])),
})
ASGI config for idea_collector 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
#calling the asgi app so the following imports work
django_asgi_app = get_asgi_application()
from idea_collector.routing import ws_urlpatterns
from channels.routing import ProtocolTypeRouter, ChannelNameRouter
from channels.auth import AuthMiddlewareStack
from channels.routing import URLRouter
from idea.consumers import TaskConsumer
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'idea_collector.settings')
application = ProtocolTypeRouter({
'http':
django_asgi_app,
'websocket':
AuthMiddlewareStack(URLRouter(ws_urlpatterns)),
'channel':
ChannelNameRouter({
'task-consumer': TaskConsumer.as_asgi(),
})
})
"""
ASGI config for studypie 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 alarms.routing import websocket_urlpatterns as alarms_urlpatterns
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'studypie.settings')
application = ProtocolTypeRouter({
"http":
get_asgi_application(),
"websocket":
AuthMiddlewareStack(URLRouter(alarms_urlpatterns))
})
# Copyright: (c) OpenSpug Organization. https://github.com/openspug/spug
# Copyright: (c) <*****@*****.**>
# Released under the AGPL-3.0 License.
from django.urls import path
from channels.routing import URLRouter
from consumer.middleware import AuthMiddleware
from consumer.consumers import *
ws_router = AuthMiddleware(
URLRouter([
path('ws/exec/<str:token>/', ExecConsumer),
path('ws/ssh/<int:id>/', SSHConsumer),
])
)
import os
from django.core.asgi import get_asgi_application
from channels.routing import ProtocolTypeRouter
from channels.auth import AuthMiddlewareStack
from channels.routing import URLRouter
from notification.routing import websockets_urlpattern
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'src.settings')
application = ProtocolTypeRouter({
'http': get_asgi_application(),
'websocket':AuthMiddlewareStack(URLRouter(
websockets_urlpattern
)),
})
from django.conf.urls import url
from channels.routing import ChannelNameRouter, ProtocolTypeRouter, URLRouter
from channels.sessions import SessionMiddlewareStack
from lactolyse.consumers import ClientConsumer, RunAnalysisConsumer
from lactolyse.protocol import RUN_ANALYSIS_CHANNEL
application = ProtocolTypeRouter({
# Client-facing consumers.
'websocket':
SessionMiddlewareStack(URLRouter([url(r'^ws/$', ClientConsumer)])),
# Background worker consumers.
'channel':
ChannelNameRouter({RUN_ANALYSIS_CHANNEL: RunAnalysisConsumer}),
})
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
import livestream.routing
application = ProtocolTypeRouter({ # includes index by default
'websocket':
AuthMiddlewareStack(URLRouter(livestream.routing.websocket_urlpatterns))
})
from django.conf.urls import url
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
from test_app.consumers import TestWebsocketView
application = ProtocolTypeRouter({
# WebSocket service handler
"websocket": AuthMiddlewareStack(
URLRouter([
url("test/", TestWebsocketView),
])
),
})
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
import chat.routing
application = ProtocolTypeRouter({
'websocket': AuthMiddlewareStack(
URLRouter(
chat.routing.channel_routing
)
),
})
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.security.websocket import AllowedHostsOriginValidator
from django.conf.urls import url
from project.consumers import ChatConsumer, EnterConsumer
application = ProtocolTypeRouter({
'websocket':
AllowedHostsOriginValidator(
AuthMiddlewareStack(
URLRouter(
[url(r"^room/", ChatConsumer),
url(r"^room2/", EnterConsumer)])))
})
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
import capstone.routing
application = ProtocolTypeRouter({
# (http->django views is added by default)
'websocket':
AuthMiddlewareStack(URLRouter(capstone.routing.websocket_urlpatterns)),
})
# mysite/routing.py
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
import myapp.routing
application = ProtocolTypeRouter({
# (http->django views is added by default)
'websocket':
AuthMiddlewareStack(URLRouter(myapp.routing.websocket_urlpatterns)),
})
from channels.auth import AuthMiddlewareStack
from django.conf.urls import url
from channels.routing import ProtocolTypeRouter, URLRouter
import chat.routing
from chat.consumers import SupportToWriterConsumer
application = ProtocolTypeRouter({
'websocket':
AuthMiddlewareStack(
URLRouter([
url(r'^chat/channel/(?P<username>[\w.@+-]+)/(?P<pk>[0-9]+)/',
SupportToWriterConsumer),
]
# chat.routing.websocket_urlpatterns
))
})
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from django.urls import path
from .consumers import ExcelConsumer
urlpatterns = [path("ws/", ExcelConsumer)]
application = ProtocolTypeRouter(
{'websocket': AuthMiddlewareStack(URLRouter(urlpatterns))})
from .wsgi import *
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
import star_wars_app.routing
application = ProtocolTypeRouter({
'websocket': AuthMiddlewareStack(
URLRouter(
star_wars_app.routing.websocket_urlpatterns
)
),
})
from channels.routing import ProtocolTypeRouter, URLRouter
from api.user import routing
from utils.auth import TokenAuthMiddlewareStack
application = ProtocolTypeRouter({
'websocket': TokenAuthMiddlewareStack(
URLRouter(
routing.websocket_urlpatterns
)
)
})
import os
from django.core.asgi import get_asgi_application
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
django_asgi_app = get_asgi_application()
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from django.urls import re_path
from .routing import websocket_urlpatterns
application = ProtocolTypeRouter({
"http":
django_asgi_app,
"websocket":
AuthMiddlewareStack(URLRouter(websocket_urlpatterns), ),
})
from channels.routing import ProtocolTypeRouter, URLRouter
from django.urls import path
from leave_management.channels_token_auth import TokenAuthMiddlewareStack
from push_notifications.consumer import MessageConsumer
application = ProtocolTypeRouter({
'websocket':
TokenAuthMiddlewareStack(
URLRouter([
path("ws/notifications", MessageConsumer),
])),
})
"""
ASGI config for calculator-django 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 channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from django.core.asgi import get_asgi_application
import calculator.routing
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'calculator-django.settings')
application = ProtocolTypeRouter({
"http":
get_asgi_application(),
"websocket":
AuthMiddlewareStack(URLRouter(calculator.routing.websocket_urlpatterns)),
})