Python AllowedHostsOriginValidatorの例

コード例 #1

ファイル: routing.py プロジェクト: keithamoss/scremsong

from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.security.websocket import AllowedHostsOriginValidator
import scremsong.app.routing

application = ProtocolTypeRouter({
    # (http->django views is added by default)
    "websocket": AllowedHostsOriginValidator(
        AuthMiddlewareStack(
            URLRouter(
                scremsong.app.routing.websocket_urlpatterns
            )
        ),
    ),
})

コード例 #2

from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.security.websocket import AllowedHostsOriginValidator
from djflow.apps.chat import routing

application = ProtocolTypeRouter({
    # (http->django views is added by default)
    'websocket':
    AllowedHostsOriginValidator(
        AuthMiddlewareStack(URLRouter(routing.websocket_urlpatterns)), ),
})

コード例 #3

from django.urls import path

from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
from channels.security.websocket import AllowedHostsOriginValidator

from froide.problem.consumers import ModerationConsumer

websocket_urls = [path('moderation/', ModerationConsumer)]

application = ProtocolTypeRouter({
    'websocket':
    AllowedHostsOriginValidator(
        AuthMiddlewareStack(URLRouter([path('ws/',
                                            URLRouter(websocket_urls))]))),
})

コード例 #4

ファイル: routing.py プロジェクト: thrillee/playmate

from django.conf.urls import url
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.security.websocket import AllowedHostsOriginValidator, OriginValidator

from chats.consumers import ChatConsumer
from chats.auth import TokenAuthMiddleware

application = ProtocolTypeRouter({
    # Empty for now (http->django views is added by default)
    'websocket':
    AllowedHostsOriginValidator(
        TokenAuthMiddleware(
            URLRouter([
                url(r"^(?P<pk>[0-9]+)/(?P<id>[0-9]+)/message/$", ChatConsumer),
            ])))
})

コード例 #5

ファイル: routing.py プロジェクト: purhan/django-loci

from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.security.websocket import AllowedHostsOriginValidator
from django.conf.urls import url

from django_loci.channels.base import location_broadcast_path
from django_loci.channels.consumers import LocationBroadcast

channel_routing = ProtocolTypeRouter({
    'websocket':
    AllowedHostsOriginValidator(
        AuthMiddlewareStack(
            URLRouter([
                url(
                    location_broadcast_path,
                    LocationBroadcast,
                    name='LocationChannel',
                )
            ])))
})

コード例 #6

ファイル: routing.py プロジェクト: Abbracx/Bloodbank

from django.conf.urls import url
from django.urls import path
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
from channels.security.websocket import AllowedHostsOriginValidator, OriginValidator
import bloodapp.routing
from bloodapp.consumers import NotifyConsumer

application = ProtocolTypeRouter({
    # (http->django views is added by default)
    'websocket':
    AllowedHostsOriginValidator(
        AuthMiddlewareStack(
            URLRouter([
                #bloodapp.routing.websocket_urlpatterns
                path('request/', NotifyConsumer),
            ])))
})

コード例 #7

ファイル: routing.py プロジェクト: ChanduArepalli/django_websocket_chat_system

from channels.routing import ProtocolTypeRouter, URLRouter
from channels.security.websocket import AllowedHostsOriginValidator, OriginValidator
from channels.auth import AuthMiddlewareStack
from django.conf.urls import url
from django.urls import path

from chat.consumer import ChatConsumer

application = ProtocolTypeRouter({
    'websocket':
    AllowedHostsOriginValidator(
        AuthMiddlewareStack(
            URLRouter([
                path('messsages/<username>/', ChatConsumer.as_asgi()),
            ])))
})

コード例 #8

from channels.routing import ProtocolTypeRouter
from channels.routing import URLRouter
from channels.auth import AuthMiddlewareStack
from channels.security.websocket import AllowedHostsOriginValidator, OriginValidator
from django.urls import path
from stories.consumers import *
#
application = ProtocolTypeRouter({
    # Empty for now (http->django views is added by default)
    'websocket':
    AllowedHostsOriginValidator(
        AuthMiddlewareStack(
            URLRouter([
                path('story/<int:pk>/', CommentConsumer),
            ])))
})

コード例 #9

ファイル: routing.py プロジェクト: SpeedConEU/donation-tracker

from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.security.websocket import AllowedHostsOriginValidator
from django.urls import path

import tracker.routing

application = ProtocolTypeRouter(
    {
        'websocket': AllowedHostsOriginValidator(
            AuthMiddlewareStack(
                URLRouter([path('/', URLRouter(tracker.routing.websocket_urlpatterns))])
            )
        ),
    }
)

コード例 #10

ファイル: routing.py プロジェクト: Michael-Gu-CA/boardgame

import os
from django.conf.urls import url
from channels.routing import ProtocolTypeRouter, URLRouter
from django.core.asgi import get_asgi_application
from channels.auth import AuthMiddlewareStack
from channels.security.websocket import AllowedHostsOriginValidator, OriginValidator
# os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'mysite.settings')

from catan.consumers import CatanConsumer, CatanRoomConsumer

application = ProtocolTypeRouter({
    # "http": get_asgi_application(),
    # Just HTTP for now. (We can add other protocols later.)
    'websocket':
    AllowedHostsOriginValidator(
        AuthMiddlewareStack(
            URLRouter([
                url(r'^catan/$', CatanConsumer),
                url(r'^catan/room/$', CatanRoomConsumer),
            ])))
})

コード例 #11

ファイル: routing.py プロジェクト: terrychang1015/azure-intelligent-edge-patterns

"""Project Protocol router.

Place websocket endpoint here.
"""

from channels.routing import ProtocolTypeRouter, URLRouter
from channels.security.websocket import AllowedHostsOriginValidator
from django.conf.urls import url

from vision_on_edge.notifications.consumers import NotificationConsumer

application = ProtocolTypeRouter(
    {
        # (http->django views is added by default)
        "websocket": AllowedHostsOriginValidator(
            URLRouter([url(r"api/notifications", NotificationConsumer)])
        )
    }
)

コード例 #12

ファイル: routing.py プロジェクト: jobalcaen/scrumbo

from channels.routing import ProtocolTypeRouter, URLRouter
from channels.security.websocket import AllowedHostsOriginValidator
from django.urls import path

from scrumbo.consumers import BoardConsumer

application = ProtocolTypeRouter({
    # Empty for now (http->django views is added by default)
    'websocket':
    AllowedHostsOriginValidator(
        URLRouter([
            path('<slug:board_url>', BoardConsumer),
        ]))
})

コード例 #13

ファイル: routing.py プロジェクト: livingstoneandrea/mtra_pro

from django.urls import path
from channels.routing import ProtocolTypeRouter, URLRouter, ChannelNameRouter
from channels.auth import AuthMiddlewareStack
from channels.security.websocket import AllowedHostsOriginValidator, OriginValidator

from notifications_app.consumers import NotificationConsumer, NoseyConsumer  # Importing notification Consumer from consumers.py

application = ProtocolTypeRouter({
    # Websocket chat handler
    'websocket':
    AllowedHostsOriginValidator(  # Only allow socket connections from the Allowed hosts in the settings.py file
        AuthMiddlewareStack(  # Session Authentication, required to use if we want to access the user details in the consumer 
            URLRouter([
                path(
                    "notifications/", NotificationConsumer.as_asgi()
                ),  # Url path for connecting to the websocket to send notifications.
                path("notifications/", NoseyConsumer.as_asgi()),
            ])), ),
})

コード例 #14

ファイル: routing.py プロジェクト: Shvidkiy-Dima/chat

from channels.routing import ProtocolTypeRouter, URLRouter
from channels.security.websocket import AllowedHostsOriginValidator
from communication.routing import websocket_urlpatterns

application = ProtocolTypeRouter({
    'websocket':
    AllowedHostsOriginValidator(URLRouter(websocket_urlpatterns))
})

コード例 #15

from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.security.websocket import AllowedHostsOriginValidator
from django.urls import path, re_path

from chat.consumers import ChatConsumer
from public_chat.consumers import *

application = ProtocolTypeRouter({
    'websocket':
    AllowedHostsOriginValidator(
        AuthMiddlewareStack(
            URLRouter([
                path('chat/<room_id>/', ChatConsumer),
                path('public_chat/<room_id>/', PublicChatConsumer),
            ]))),
})

コード例 #16

ファイル: asgi.py プロジェクト: atb00ker/django-loci

from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.security.websocket import AllowedHostsOriginValidator
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',
                        )
                    ]
                )
            )
        )
    }
)

コード例 #17

ファイル: routing.py プロジェクト: zigellsn/StagyBee

#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.

from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter, ChannelNameRouter
from channels.security.websocket import AllowedHostsOriginValidator
from django.core.asgi import get_asgi_application
from django.urls import re_path

from console import routing as console_routing
from stage import routing as stage_routing

urlpatterns = stage_routing.websocket_urlpatterns + console_routing.urlpatterns

http_urlpatterns = stage_routing.http_urlpatterns + [
    re_path(r"", get_asgi_application())
]

application = ProtocolTypeRouter({
    "http":
    AuthMiddlewareStack(URLRouter(http_urlpatterns)),
    "websocket":
    AllowedHostsOriginValidator(AuthMiddlewareStack(URLRouter(urlpatterns)), ),
    "channel":
    ChannelNameRouter(stage_routing.workers),
})

コード例 #18

from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.security.websocket import AllowedHostsOriginValidator
from django.urls import path

from Rehabilitation.consumers import MassagesConsumer

# self.scope['type']获取协议类型
# channels routing 是scope 级别的 ,一个连接只能由一个consumer接受和处理

application = ProtocolTypeRouter({
    'websocket':
    AllowedHostsOriginValidator(
        AuthMiddlewareStack(URLRouter([path('ws/<str:id>/',
                                            MassagesConsumer)])))
})

# AllowedHostsOriginValidator 防止通过websocket 进行CSRF 攻击
# AuthMiddlewareStack 用于 WebSocket 集成了 CookieMiddleWare, SessionMiddleWare, AuthMiddleWare,

コード例 #19

from channels.security.websocket import AllowedHostsOriginValidator, OriginValidator

from bSocial.channelsmiddleware import TokenAuthMiddleware
from main.consumers import PostConsumer
from django.urls import path

# application = ProtocolTypeRouter({
#     # Empty for now (http->django views is added by default)
#     'websocket': AllowedHostsOriginValidator(
#         AuthMiddlewareStack(
#             URLRouter(
#                 [
#                     url('', PostConsumer)
#                 ]
#             )
#         )
#     )
# })

application = ProtocolTypeRouter({
    "websocket": AllowedHostsOriginValidator(
        TokenAuthMiddleware(
            URLRouter([
                path("notifications/", PostConsumer),
            ])
        )
    )
})

コード例 #20

from channels.routing import ProtocolTypeRouter, URLRouter
from django.conf.urls import url
from django.urls import path, re_path
from channels.auth import AuthMiddlewareStack
from channels.security.websocket import AllowedHostsOriginValidator, OriginValidator

#from chatconsumers import ChatConsumer
from chat.consumers import ChatConsumer

application = ProtocolTypeRouter({
    # Empty for now (http->django views is added by default)
    'websocket':
    AllowedHostsOriginValidator(
        URLRouter([
            re_path(r"^messages/(?P<username>[\w.@+-]+)", ChatConsumer),
        ]))
})
#r"^messages/(?P<username>[\w.@+-]+)/$"

コード例 #21

from django.conf.urls import url
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.security.websocket import AllowedHostsOriginValidator, OriginValidator

from complex_design_backend.consumers import wsconsumer
'''
from channels.staticfiles import StaticFilesConsumer
from complex_design_backend.consumers import wsconsumer

channel_routing = {
    # This makes Django serve static files from settings.STATIC_URL, similar
    # to django.views.static.serve. This isn't ideal (not exactly production
    # quality) but it works for a minimal example.
    'http.request': StaticFilesConsumer(),

    # Wire up websocket channels to our consumers:
    'websocket.connect':  wsconsumer.websocket_connect,
    'websocket.receive':  wsconsumer.websocket_receive,
    'websocket.disconnect': wsconsumer.websocket_disconnect,
}'''

application = ProtocolTypeRouter({
    # Empty for now (http->django views is added by default)
    'websocket':
    AllowedHostsOriginValidator(
        AuthMiddlewareStack(URLRouter([url('wsnotif', wsconsumer)])))
})

コード例 #22

ファイル: routing.py プロジェクト: nikitko43/memo

from channels.sessions import SessionMiddlewareStack
from django.conf.urls import url, re_path
from channels.routing import ProtocolTypeRouter, URLRouter, ChannelNameRouter
from channels.auth import AuthMiddlewareStack
from channels.security.websocket import AllowedHostsOriginValidator, OriginValidator

from chat.consumers import ChatConsumer, TaskConsumer
from render.consumers import RenderConsumer, ServerConsumer
from sketchbook.consumers import SketchbookConsumer

application = ProtocolTypeRouter({
    # Websocket chat handler
    'websocket':
        AllowedHostsOriginValidator(
            AuthMiddlewareStack(
                URLRouter(
                    [
                        re_path(r"^messages/(?P<username>[\w.@+-]+)$", ChatConsumer(), name='chat'),
                        re_path(r"^api/render/$", RenderConsumer(), name='render'),
                        re_path(r"^server_info$", ServerConsumer(), name='server'),
                        re_path(r"^ws/sketchbook/$", SketchbookConsumer().as_asgi(), name='sketchbook'),
                    ]
                )
            ),
        ),
    'channel': ChannelNameRouter({
        'task': TaskConsumer
    })
})

コード例 #23

from django.conf.urls import url
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.security.websocket import AllowedHostsOriginValidator
from channels.auth import AuthMiddlewareStack

from SibDev.consumers import UrlConsumer

application = ProtocolTypeRouter({
    'websocket':
    AllowedHostsOriginValidator(
        AuthMiddlewareStack(URLRouter([url(r'^$', UrlConsumer)])))
})

コード例 #24

ファイル: routing.py プロジェクト: pnp-zone/pnp-zone

from django.core.asgi import get_asgi_application
from django.urls import re_path
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.security.websocket import AllowedHostsOriginValidator
from channels.auth import AuthMiddlewareStack

import board.routing

application = ProtocolTypeRouter({
    "http": get_asgi_application(),
    "websocket": AllowedHostsOriginValidator(
        AuthMiddlewareStack(
            URLRouter([
                re_path("board/", URLRouter(board.routing.urlpatterns))
            ])
        )
    )
})

コード例 #25

ファイル: routing.py プロジェクト: laingsoft/BioLargo

from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter, ChannelNameRouter
import app.routing
import analytics.routing
from django.conf.urls import url, include
from channels.security.websocket import AllowedHostsOriginValidator

application = ProtocolTypeRouter({
    # (http->django views is added by default)
    'websocket':
    AllowedHostsOriginValidator(
        AuthMiddlewareStack(
            URLRouter([
                url('app/', include(app.routing.websocket_urlpatterns)),
                url('analytics/',
                    include(analytics.routing.websocket_urlpatterns)),
            ]))),
})

コード例 #26

ファイル: routing.py プロジェクト: sajalmia381/simple-chap-app

from django.conf.urls import url
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
from channels.security.websocket import AllowedHostsOriginValidator, OriginValidator

from chat.consumes 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),
            ])))
})

コード例 #27

from django.conf.urls import url
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import  AuthMiddlewareStack
from channels.security.websocket import AllowedHostsOriginValidator, OriginValidator


from gnss_iot.consumer import GnssConsumer
application = ProtocolTypeRouter({
    # Empty for now (http->django views is added by default)
    'websocket': AllowedHostsOriginValidator(
        AuthMiddlewareStack(
            URLRouter(
                [
                    url(r"^(?P<username>[\w.@+-]+)",GnssConsumer),
                ]
            )
        )
    )
})

コード例 #28

ファイル: routing.py プロジェクト: radekska/django-network-controller

from django.conf.urls import url
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
from channels.security.websocket import AllowedHostsOriginValidator, OriginValidator

from manage_app.consumers import SSHConsumer
""" Creating ASGI WebSocket url"""

application = ProtocolTypeRouter({
    'websocket':
    AllowedHostsOriginValidator(
        AuthMiddlewareStack(
            URLRouter(
                [url(r'^dashboard/manage_network/', SSHConsumer.as_asgi())])))
})

コード例 #29

ファイル: routing.py プロジェクト: arahimli/task-app-project

from django.conf.urls import url
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
from channels.security.websocket import AllowedHostsOriginValidator, OriginValidator

from content.consumers import CommentConsumer
application = ProtocolTypeRouter({
    'websocket':
    AllowedHostsOriginValidator(
        AuthMiddlewareStack(
            URLRouter([
                url(r"^files/details/(?P<id>[\w.@+-]+)/$", CommentConsumer),
            ])))
})

コード例 #30

from channels.security.websocket import AllowedHostsOriginValidator
# from channels.auth import AuthMiddlewareStack
from api.middleware.authentication import TokenAuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter

import api.routing

application = ProtocolTypeRouter({
    'websocket':
    AllowedHostsOriginValidator(
        TokenAuthMiddlewareStack(URLRouter(api.routing.websocket_urlpatterns)))
})