Ejemplo n.º 1
0
    def test_websocket_demultiplexer_send(self):
        class MyWebsocketConsumer(websockets.JsonWebsocketConsumer):
            def receive(self, content, multiplexer=None, **kwargs):
                import pdb
                pdb.set_trace()  # breakpoint 69f2473b //

                self.send(content)

        class Demultiplexer(websockets.WebsocketDemultiplexer):

            consumers = {"mystream": MyWebsocketConsumer}

        with apply_routes([
                route_class(Demultiplexer, path='/path/(?P<id>\d+)'),
                route_class(MyWebsocketConsumer),
        ]):
            client = Client()

            with self.assertRaises(SendNotAvailableOnDemultiplexer):
                client.send_and_consume(
                    'websocket.receive', {
                        'path':
                        '/path/1',
                        'text':
                        json.dumps({
                            "stream": "mystream",
                            "payload": {
                                "text_field": "mytext"
                            }
                        })
                    })

                client.receive()
Ejemplo n.º 2
0
    def test_websockets_consumers_handlers(self):

        class WebsocketConsumer(websockets.WebsocketConsumer):

            def connect(self, message, **kwargs):
                self.called = 'connect'
                self.id = kwargs['id']

            def disconnect(self, message, **kwargs):
                self.called = 'disconnect'

            def receive(self, text=None, bytes=None, **kwargs):
                self.text = text

        with apply_routes([route_class(WebsocketConsumer, path='/path/(?P<id>\d+)')]):
            client = Client()

            consumer = client.send_and_consume('websocket.connect', {'path': '/path/1'})
            self.assertEqual(consumer.called, 'connect')
            self.assertEqual(consumer.id, '1')

            consumer = client.send_and_consume('websocket.receive', {'path': '/path/1', 'text': 'text'})
            self.assertEqual(consumer.text, 'text')

            consumer = client.send_and_consume('websocket.disconnect', {'path': '/path/1'})
            self.assertEqual(consumer.called, 'disconnect')
Ejemplo n.º 3
0
    def test_websocket_custom_json_serialization(self):

        class WebsocketConsumer(websockets.JsonWebsocketConsumer):
            @classmethod
            def decode_json(cls, text):
                obj = json.loads(text)
                return dict((key.upper(), obj[key]) for key in obj)

            @classmethod
            def encode_json(cls, content):
                lowered = dict((key.lower(), content[key]) for key in content)
                return json.dumps(lowered)

            def receive(self, content, multiplexer=None, **kwargs):
                self.content_received = content
                self.send({"RESPONSE": "HI"})

        class MyMultiplexer(websockets.WebsocketMultiplexer):
            @classmethod
            def encode_json(cls, content):
                lowered = dict((key.lower(), content[key]) for key in content)
                return json.dumps(lowered)

        with apply_routes([route_class(WebsocketConsumer, path='/path')]):
            client = HttpClient()

            consumer = client.send_and_consume('websocket.receive', path='/path', text={"key": "value"})
            self.assertEqual(consumer.content_received, {"KEY": "value"})

            self.assertEqual(client.receive(), {"response": "HI"})

            client.join_group('test_group')
            WebsocketConsumer.group_send('test_group', {"KEY": "VALUE"})
            self.assertEqual(client.receive(), {"key": "VALUE"})
Ejemplo n.º 4
0
    def test_websockets_demultiplexer_custom_multiplexer(self):

        class MyWebsocketConsumer(websockets.JsonWebsocketConsumer):
            def connect(self, message, multiplexer=None, **kwargs):
                multiplexer.send({"THIS_SHOULD_BE_LOWERCASED": "1"})

        class MyMultiplexer(websockets.WebsocketMultiplexer):
            @classmethod
            def encode_json(cls, content):
                lowered = {
                    "stream": content["stream"],
                    "payload": dict((key.lower(), content["payload"][key]) for key in content["payload"])
                }
                return json.dumps(lowered)

        class Demultiplexer(websockets.WebsocketDemultiplexer):
            multiplexer_class = MyMultiplexer

            consumers = {
                "mystream": MyWebsocketConsumer
            }

        with apply_routes([route_class(Demultiplexer, path='/path/(?P<ID>\d+)')]):
            client = HttpClient()

            client.send_and_consume('websocket.connect', path='/path/1')
            self.assertEqual(client.receive(), {
                "stream": "mystream",
                "payload": {"this_should_be_lowercased": "1"},
            })
Ejemplo n.º 5
0
    def test_websocket_custom_json_serialization(self):
        class WebsocketConsumer(websockets.JsonWebsocketConsumer):
            @classmethod
            def decode_json(cls, text):
                obj = json.loads(text)
                return dict((key.upper(), obj[key]) for key in obj)

            @classmethod
            def encode_json(cls, content):
                lowered = dict((key.lower(), content[key]) for key in content)
                return json.dumps(lowered)

            def receive(self, content, multiplexer=None, **kwargs):
                self.content_received = content
                self.send({"RESPONSE": "HI"})

        class MyMultiplexer(websockets.WebsocketMultiplexer):
            @classmethod
            def encode_json(cls, content):
                lowered = dict((key.lower(), content[key]) for key in content)
                return json.dumps(lowered)

        with apply_routes([route_class(WebsocketConsumer, path='/path')]):
            client = WSClient()

            consumer = client.send_and_consume('websocket.receive',
                                               path='/path',
                                               text={"key": "value"})
            self.assertEqual(consumer.content_received, {"KEY": "value"})

            self.assertEqual(client.receive(), {"response": "HI"})

            client.join_group('test_group')
            WebsocketConsumer.group_send('test_group', {"KEY": "VALUE"})
            self.assertEqual(client.receive(), {"key": "VALUE"})
Ejemplo n.º 6
0
    def test_base_consumer(self):

        class Consumers(BaseConsumer):

            method_mapping = {
                'test.create': 'create',
                'test.test': 'test',
            }

            def create(self, message, **kwargs):
                self.called = 'create'

            def test(self, message, **kwargs):
                self.called = 'test'

        with apply_routes([route_class(Consumers)]):
            client = Client()

            #  check that methods for certain channels routes successfully
            self.assertEqual(client.send_and_consume('test.create').called, 'create')
            self.assertEqual(client.send_and_consume('test.test').called, 'test')

            #  send to the channels without routes
            client.send('test.wrong')
            message = self.get_next_message('test.wrong')
            self.assertEqual(client.channel_layer.router.match(message), None)

            client.send('test')
            message = self.get_next_message('test')
            self.assertEqual(client.channel_layer.router.match(message), None)
Ejemplo n.º 7
0
    def test_websockets_demultiplexer_custom_multiplexer(self):
        class MyWebsocketConsumer(websockets.JsonWebsocketConsumer):
            def connect(self, message, multiplexer=None, **kwargs):
                multiplexer.send({"THIS_SHOULD_BE_LOWERCASED": "1"})

        class MyMultiplexer(websockets.WebsocketMultiplexer):
            @classmethod
            def encode_json(cls, content):
                lowered = {
                    "stream":
                    content["stream"],
                    "payload":
                    dict((key.lower(), content["payload"][key])
                         for key in content["payload"])
                }
                return json.dumps(lowered)

        class Demultiplexer(websockets.WebsocketDemultiplexer):
            multiplexer_class = MyMultiplexer

            consumers = {"mystream": MyWebsocketConsumer}

        with apply_routes(
            [route_class(Demultiplexer, path='/path/(?P<ID>\d+)')]):
            client = WSClient()

            client.send_and_consume('websocket.connect', path='/path/1')
            self.assertEqual(
                client.receive(), {
                    "stream": "mystream",
                    "payload": {
                        "this_should_be_lowercased": "1"
                    },
                })
Ejemplo n.º 8
0
    def test_base_consumer(self):
        class Consumers(BaseConsumer):

            method_mapping = {
                'test.create': 'create',
                'test.test': 'test',
            }

            def create(self, message, **kwargs):
                self.called = 'create'

            def test(self, message, **kwargs):
                self.called = 'test'

        with apply_routes([route_class(Consumers)]):
            client = Client()

            #  check that methods for certain channels routes successfully
            self.assertEqual(
                client.send_and_consume('test.create').called, 'create')
            self.assertEqual(
                client.send_and_consume('test.test').called, 'test')

            #  send to the channels without routes
            client.send('test.wrong')
            message = self.get_next_message('test.wrong')
            self.assertEqual(client.channel_layer.router.match(message), None)

            client.send('test')
            message = self.get_next_message('test')
            self.assertEqual(client.channel_layer.router.match(message), None)
Ejemplo n.º 9
0
    def test_websockets_consumers_handlers(self):
        class WebsocketConsumer(websockets.WebsocketConsumer):
            def connect(self, message, **kwargs):
                self.called = 'connect'
                self.id = kwargs['id']

            def disconnect(self, message, **kwargs):
                self.called = 'disconnect'

            def receive(self, text=None, bytes=None, **kwargs):
                self.text = text

        with apply_routes(
            [route_class(WebsocketConsumer, path='/path/(?P<id>\d+)')]):
            client = Client()

            consumer = client.send_and_consume('websocket.connect',
                                               {'path': '/path/1'})
            self.assertEqual(consumer.called, 'connect')
            self.assertEqual(consumer.id, '1')

            consumer = client.send_and_consume('websocket.receive', {
                'path': '/path/1',
                'text': 'text'
            })
            self.assertEqual(consumer.text, 'text')

            consumer = client.send_and_consume('websocket.disconnect',
                                               {'path': '/path/1'})
            self.assertEqual(consumer.called, 'disconnect')
Ejemplo n.º 10
0
    def test_websockets_demultiplexer(self):
        class MyWebsocketConsumer(websockets.JsonWebsocketConsumer):
            def connect(self, message, multiplexer=None, **kwargs):
                multiplexer.send(kwargs)

            def disconnect(self, message, multiplexer=None, **kwargs):
                multiplexer.send(kwargs)

            def receive(self, content, multiplexer=None, **kwargs):
                multiplexer.send(content)

        class Demultiplexer(websockets.WebsocketDemultiplexer):

            consumers = {"mystream": MyWebsocketConsumer}

        with apply_routes(
            [route_class(Demultiplexer, path='/path/(?P<id>\d+)')]):
            client = WSClient()

            client.send_and_consume('websocket.connect', path='/path/1')
            self.assertEqual(client.receive(), {
                "stream": "mystream",
                "payload": {
                    "id": "1"
                },
            })

            client.send_and_consume('websocket.receive',
                                    text={
                                        "stream": "mystream",
                                        "payload": {
                                            "text_field": "mytext"
                                        },
                                    },
                                    path='/path/1')
            self.assertEqual(client.receive(), {
                "stream": "mystream",
                "payload": {
                    "text_field": "mytext"
                },
            })

            client.send_and_consume('websocket.disconnect', path='/path/1')
            self.assertEqual(client.receive(), {
                "stream": "mystream",
                "payload": {
                    "id": "1"
                },
            })
Ejemplo n.º 11
0
    def test_websockets_decorators(self):
        class WebsocketConsumer(websockets.WebsocketConsumer):
            strict_ordering = True

            def connect(self, message, **kwargs):
                self.order = message['order']

        with apply_routes([route_class(WebsocketConsumer, path='/path')]):
            client = Client()

            client.send('websocket.connect', {'path': '/path', 'order': 1})
            client.send('websocket.connect', {'path': '/path', 'order': 0})
            client.consume('websocket.connect')
            self.assertEqual(client.consume('websocket.connect').order, 0)
            self.assertEqual(client.consume('websocket.connect').order, 1)
Ejemplo n.º 12
0
    def test_websockets_decorators(self):
        class WebsocketConsumer(websockets.WebsocketConsumer):
            slight_ordering = True

            def connect(self, message, **kwargs):
                self.order = message['order']

        with apply_routes([route_class(WebsocketConsumer, path='/path')]):
            client = Client()

            client.send('websocket.connect', {'path': '/path', 'order': 1})
            client.send('websocket.connect', {'path': '/path', 'order': 0})
            client.consume('websocket.connect')
            self.assertEqual(client.consume('websocket.connect').order, 0)
            self.assertEqual(client.consume('websocket.connect').order, 1)
Ejemplo n.º 13
0
    def test_websockets_demultiplexer(self):

        class MyWebsocketConsumer(websockets.JsonWebsocketConsumer):
            def connect(self, message, multiplexer=None, **kwargs):
                multiplexer.send(kwargs)

            def disconnect(self, message, multiplexer=None, **kwargs):
                multiplexer.send(kwargs)

            def receive(self, content, multiplexer=None, **kwargs):
                multiplexer.send(content)

        class Demultiplexer(websockets.WebsocketDemultiplexer):

            consumers = {
                "mystream": MyWebsocketConsumer
            }

        with apply_routes([route_class(Demultiplexer, path='/path/(?P<id>\d+)')]):
            client = HttpClient()

            client.send_and_consume('websocket.connect', path='/path/1')
            self.assertEqual(client.receive(), {
                "stream": "mystream",
                "payload": {"id": "1"},
            })

            client.send_and_consume('websocket.receive', text={
                "stream": "mystream",
                "payload": {"text_field": "mytext"},
            }, path='/path/1')
            self.assertEqual(client.receive(), {
                "stream": "mystream",
                "payload": {"text_field": "mytext"},
            })

            client.send_and_consume('websocket.disconnect', path='/path/1')
            self.assertEqual(client.receive(), {
                "stream": "mystream",
                "payload": {"id": "1"},
            })
Ejemplo n.º 14
0
    def test_websockets_http_session_and_channel_session(self):

        class WebsocketConsumer(websockets.WebsocketConsumer):
            http_user_and_session = True

        user_model = get_user_model()
        user = user_model.objects.create_user(username='******', email='*****@*****.**', password='******')

        client = HttpClient()
        client.force_login(user)
        with apply_routes([route_class(WebsocketConsumer, path='/path')]):
            connect = client.send_and_consume('websocket.connect', {'path': '/path'})
            receive = client.send_and_consume('websocket.receive', {'path': '/path'}, text={'key': 'value'})
            disconnect = client.send_and_consume('websocket.disconnect', {'path': '/path'})
        self.assertEqual(
            connect.message.http_session.session_key,
            receive.message.http_session.session_key
        )
        self.assertEqual(
            connect.message.http_session.session_key,
            disconnect.message.http_session.session_key
        )
Ejemplo n.º 15
0
    def test_websocket_demultiplexer_send(self):

        class MyWebsocketConsumer(websockets.JsonWebsocketConsumer):
            def receive(self, content, multiplexer=None, **kwargs):
                self.send(content)

        class Demultiplexer(websockets.WebsocketDemultiplexer):

            consumers = {
                "mystream": MyWebsocketConsumer
            }

        with apply_routes([route_class(Demultiplexer, path='/path/(?P<id>\d+)')]):
            client = HttpClient()

            with self.assertRaises(SendNotAvailableOnDemultiplexer):
                client.send_and_consume('websocket.receive', path='/path/1', text={
                    "stream": "mystream",
                    "payload": {"text_field": "mytext"},
                })

                client.receive()
Ejemplo n.º 16
0
    def test_websocket_demultiplexer_send(self):

        class MyWebsocketConsumer(websockets.JsonWebsocketConsumer):
            def receive(self, content, multiplexer=None, **kwargs):
                self.send(content)

        class Demultiplexer(websockets.WebsocketDemultiplexer):

            consumers = {
                "mystream": MyWebsocketConsumer
            }

        with apply_routes([route_class(Demultiplexer, path='/path/(?P<id>\d+)')]):
            client = HttpClient()

            with self.assertRaises(SendNotAvailableOnDemultiplexer):
                client.send_and_consume('websocket.receive', path='/path/1', text={
                    "stream": "mystream",
                    "payload": {"text_field": "mytext"},
                })

                client.receive()
Ejemplo n.º 17
0
from channels import route_class, route
from values.consumers import Demultiplexer
from values.models import IntegerValueBinding


# The channel routing defines what channels get handled by what consumers,
# including optional matching on message attributes. In this example, we route
# all WebSocket connections to the class-based BindingConsumer (the consumer
# class itself specifies what channels it wants to consume)
channel_routing = [
    route_class(Demultiplexer),
    route("binding.intval", IntegerValueBinding.consumer),
]
Ejemplo n.º 18
0
from channels import route_class

from .consumers import PresenceConsumer


# The channel routing defines what channels get handled by what consumers,
# including optional matching on message attributes. WebSocket messages of all
# types have a 'path' attribute, so we're using that to route the socket.
# While this is under stream/ compared to the HTML page, we could have it on the
# same URL if we wanted; Daphne separates by protocol as it negotiates with a browser.
channel_routing = [
    route_class(PresenceConsumer, path=r'^/ws/$'),
]
Ejemplo n.º 19
0
from channels import route, route_class
from channels.staticfiles import StaticFilesConsumer
from .logserver import LogSubscriptionConsumer

channel_routing = [
    route('http.request', StaticFilesConsumer()),
    route_class(LogSubscriptionConsumer, path=r"^/log(?P<path>.+)"),
]
Ejemplo n.º 20
0
from channels import route_class
from codenerix_pos.consumers import POSConsumer
# from channels.routing import route
# from codenerix_pos.consumers import ws_message, ws_connect, ws_disconnect

channel_routing = [
    route_class(POSConsumer, path=r"^/codenerix_pos/"),
]
# channel_routing = [
#    route("websocket.connect", ws_connect, path=r"^\/codenerix_pos\/(?P<uid>[a-zA-Z0-9_]+)$"),
#    route("websocket.receive", ws_message, path=r"^/codenerix_pos/(?P<uid>[a-zA-Z0-9_]+)$"),
#    route("websocket.disconnect", ws_disconnect, path=r"^/codenerix_pos/(?P<uid>[a-zA-Z0-9_]+)$"),
# ]
Ejemplo n.º 21
0
from channels import route, route_class
from inbox.consumers import ChatServer

channel_routing = [
    route_class(ChatServer, path=r"^/realtime/"),
]
Ejemplo n.º 22
0
from channels import route_class, route
from values.consumers import Demultiplexer
from values.models import IntegerValueBinding


# The channel routing defines what channels get handled by what consumers,
# including optional matching on message attributes. In this example, we route
# all WebSocket connections to the class-based BindingConsumer (the consumer
# class itself specifies what channels it wants to consume)
channel_routing = [
    route_class(Demultiplexer, path='^/stream/?$'),
    route("binding.intval", IntegerValueBinding.consumer),
]
Ejemplo n.º 23
0
from channels import route, route_class

from branches.consumers import ServerDetailPageConsumer

channel_routing = [
    # route_class(ServerDetailPageConsumer, path="^/server/(?P<server>[\w\-_]+)"),
    route_class(ServerDetailPageConsumer, path="^/(?P<owner>[\w\-_])+/(?P<project>[\w\-_]+)/(?P<server>[\w\-_]+)"),
    # route("websocket.connect", "branches.consumers.server_page", path="^/server/(?P<server>[\w\-_]+)"),
    route("websocket.disconnect", "branches.consumers.server_page_disconnect", path="^/server/(?P<server>[\w\-_]+)"),
    route("websocket.receive", "branches.consumers.ws_receive"),
]
Ejemplo n.º 24
0
#-*- coding:utf-8 -*-
from channels import route_class, route
from devops.consumers import webterminal,SshTerminalMonitor

# The channel routing defines what channels get handled by what consumers,
# including optional matching on message attributes. In this example, we route
# all WebSocket connections to the class-based BindingConsumer (the consumer
# class itself specifies what channels it wants to consume)
channel_routing = [
    route_class(webterminal,path = r'^/ws'),
    route_class(SshTerminalMonitor,path= r'^/monitor/(?P<channel>\w+-\w+-\w+-\w+-\w+-\w+)'),
]
Ejemplo n.º 25
0
from blocks.consumers.info import display_info
from blocks.consumers.websockets import ws_connect, ws_disconnect, ws_receive
from blocks.consumers.angular_consumers.demultiplexers import BlockDemultiplexer, LatestBlocksDemultiplexer

channel_routing = [
    # Blocks
    route('parse_block', parse_block),
    route('repair_block', repair_block),
    route('check_block_hash', check_block_hash),

    # Transactions
    route('repair_transaction', repair_transaction),

    # Addresses
    route('parse_address', parse_address),

    # Info
    route('display_info', display_info),

    # Demultiplexing
    route_class(BlockDemultiplexer, path="^/block/$"),
    route_class(LatestBlocksDemultiplexer, path="^/latest_blocks/$"),

    # Websockets
    route('websocket.connect', ws_connect),
    route('websocket.disconnect', ws_disconnect),
    route('websocket.receive', ws_receive),


]
Ejemplo n.º 26
0
from channels import route_class, route
from guacamole.consumers import GuacamoleWebsocket
# The channel routing defines what channels get handled by what consumers,
# including optional matching on message attributes. In this example, we route
# all WebSocket connections to the class-based BindingConsumer (the consumer
# class itself specifies what channels it wants to consume)
channel_routing = [
    route_class(GuacamoleWebsocket, path=r'^/ws'),
]
Ejemplo n.º 27
0
from channels import route_class
from channels.generic.websockets import WebsocketDemultiplexer

from api.bindings import GameBinding


class APIDemultiplexer(WebsocketDemultiplexer):
    http_user = True

    consumers = {'games': GameBinding.consumer}


channel_routing = [
    route_class(APIDemultiplexer),
]
Ejemplo n.º 28
0
from channels import route_class
from . import consumers


channel_routing = [
    route_class(consumers.SensorConsumer, path=r'^/room/[0-9A-F]{16}/sensor'),
    route_class(consumers.ClientConsumer, path=r'^/room/[0-9A-F]{16}/client'),
    route_class(consumers.ClientConsumer, path=r'^/room/[0-9A-F]{16}/stats'),
    route_class(consumers.ClientConsumer, path=r'^/room/[0-9A-F]{16}/map'),
]
Ejemplo n.º 29
0
from minesweeper import consumers
from channels import route_class

channel_routing = [
    route_class(consumers.GameConsumer,
                path=r"^/minesweeper/stream/(?P<game_id>[^/]+)")
]
Ejemplo n.º 30
0
from channels import route, route_class
from channels.generic.websockets import WebsocketDemultiplexer

from posts.bindings import LiveblogResource

class APIDemultiplexer(WebsocketDemultiplexer):

    mapping = {
        'liveblogs': 'liveblogs'
    }


# The channel routing defines what channels get handled by what consumers,
# including optional matching on message attributes. WebSocket messages of all
# types have a 'path' attribute, so we're using that to route the socket.
# While this is under stream/ compared to the HTML page, we could have it on the
# same URL if we wanted; Daphne separates by protocol as it negotiates with a browser.
channel_routing = [
    route_class(APIDemultiplexer),
    route("liveblogs", LiveblogResource.consumer)

    # A default "http.request" route is always inserted by Django at the end of the routing list
    # that routes all unmatched HTTP requests to the Django view system. If you want lower-level
    # HTTP handling - e.g. long-polling - you can do it here and route by path, and let the rest
    # fall through to normal views.
]
Ejemplo n.º 31
0
from channels import route, route_class

from main import consumers

channel_routing = [
    route_class(consumers.WSConsumer, path=r"^/$"),
]
Ejemplo n.º 32
0
from channels import route_class, route
from webterminallte.consumers import Webterminal, SshTerminalMonitor

# The channel routing defines what channels get handled by what consumers,
# including optional matching on message attributes. In this example, we route
# all WebSocket connections to the class-based BindingConsumer (the consumer
# class itself specifies what channels it wants to consume)
channel_routing = [
    route_class(
        Webterminal,
        path=
        r'^/ws/(?P<ip>(?:(?:0|1[\d]{0,2}|2(?:[0-4]\d?|5[0-5]?|[6-9])?|[3-9]\d?)\.){3}(?:0|1[\d]{0,2}|2(?:[0-4]\d?|5[0-5]?|[6-9])?|[3-9]\d?))/(?P<id>[\w]+)/$'
    ),
    route_class(SshTerminalMonitor,
                path=r'^/monitor/(?P<channel>[\w-]+)/(?P<id>[\w]+)/$'),
]
Ejemplo n.º 33
0
from channels import route_class
from channelstest import consumers

channel_routing = [route_class(consumers.ChannelsTestConsumer)]
Ejemplo n.º 34
0
from channels import route, route_class
from myproject.core.websocket_handler import NewsConsumer

channel_routing = [
    route_class(NewsConsumer, path=r"^/chat/"),
]
Ejemplo n.º 35
0
from channels import route_class, route
from webterminal.consumers import webterminal, CommandExecute, SshTerminalMonitor, BatchCommandExecute
from guacamole.consumers import GuacamoleWebsocket, GuacamoleMonitor

# The channel routing defines what channels get handled by what consumers,
# including optional matching on message attributes. In this example, we route
# all WebSocket connections to the class-based BindingConsumer (the consumer
# class itself specifies what channels it wants to consume)
channel_routing = [
    route_class(webterminal, path=r'^/ws'),
    route_class(CommandExecute, path=r'^/execute'),
    route_class(SshTerminalMonitor,
                path=r'^/monitor/(?P<channel>\w+-\w+-\w+-\w+-\w+-\w+)'),
    route_class(GuacamoleWebsocket, path=r'^/guacamole/(?P<id>[0-9]+)/'),
    route_class(GuacamoleMonitor, path=r'^/guacamolemonitor/(?P<id>[0-9]+)/'),
    route_class(BatchCommandExecute, path=r'^/batchexecute/'),
]
Ejemplo n.º 36
0
# -*- coding: utf-8 -*-
from channels import route_class
from webterminal.consumers import Webterminal, SshTerminalMonitor, BatchCommandExecute
from ansible_task.consumers import AnsModuleConsumer, AnsPlaybookConsumer
channel_routing = [
    route_class(Webterminal, path=r'^/ws/webssh/'),
    route_class(AnsModuleConsumer, path=r'^/ws/adhocrun/'),
    route_class(AnsPlaybookConsumer, path=r'^/ws/playbookrun/'),
    route_class(SshTerminalMonitor, path=r'^/monitor/(?P<channel>[\w-]+)'),
    route_class(BatchCommandExecute, path=r'^/batchexecute/'),
]
Ejemplo n.º 37
0
from channels import route_class, route
from webterminal.consumers import webterminal, CommandExecute, SshTerminalMonitor

# The channel routing defines what channels get handled by what consumers,
# including optional matching on message attributes. In this example, we route
# all WebSocket connections to the class-based BindingConsumer (the consumer
# class itself specifies what channels it wants to consume)
channel_routing = [
    route_class(webterminal, path=r'^/ws'),
    route_class(CommandExecute, path=r'^/execute'),
    route_class(SshTerminalMonitor,
                path=r'^/monitor/(?P<channel>\w+-\w+-\w+-\w+-\w+-\w+)'),
]
Ejemplo n.º 38
0
from channels import route, route_class
from chat import consumers as chatConsumer
from notification import consumers as notifyConsumer

channel_routing = [
    #route_class(chatConsumer.MyConsumer),
    route_class(chatConsumer.MyConsumer, path=r'/doc/[0-9]+'),
    route_class(notifyConsumer.MyConsumer, path=r'/notify'),
]
Ejemplo n.º 39
0
from channels import (route, route_class)

from .bindings import Demultiplexer
from .consumers import Consumer
from .views import chat_receive

websocket_routing = [
    route_class(Demultiplexer, path=r"^/bindings$"),
    Consumer.as_route(path=r"^/(?P<channel>[a-zA-Z0-9_]+)$"),
]

custom_routing = [
    route("chat.receive", chat_receive),
]
Ejemplo n.º 40
0
from channels import route, route_class
from .consumers import ChatServer, events, Demultiplexer, RoomBinding

chat_routing = [
    route_class(ChatServer, path=r'^(?P<slug>[^/]+)/stream/$'),
]

event_routing = [
    route('chat.receive', events.user_join, event=r'^user-join$'),
    route('chat.receive', events.user_leave, event=r'^user-leave$'),
    route('chat.receive', events.client_send, event=r'^message-send$'),
]

binding_routing = [
    route_class(Demultiplexer, path=r'^/binding/'),
    route('binding.room', RoomBinding.consumer),
]
Ejemplo n.º 41
0
from channels import route_class, route
from OpsManage.consumers import webterminal

# The channel routing defines what channels get handled by what consumers,
# including optional matching on message attributes. In this example, we route
# all WebSocket connections to the class-based BindingConsumer (the consumer
# class itself specifies what channels it wants to consume)
channel_routing = [
    route_class(webterminal, path=r'^/ws'),
]
Ejemplo n.º 42
0
from channels import route_class

from socialhome.streams.consumers import StreamConsumer

channel_routing = [
    route_class(StreamConsumer, path=r'^/ch/streams/(?P<stream>[^/]+)/$'),
]
Ejemplo n.º 43
0
from channels import route_class

from excon_service.consumers import Demultiplexer

trip_service_routing = [
]

channel_routing = [
    route_class(Demultiplexer, path="^/api/v1/ws"),
]
Ejemplo n.º 44
0
from channels import route_class
from channels.generic.websockets import WebsocketDemultiplexer
from .test_bindings import TestModelResourceBinding


class TestDemultiplexer(WebsocketDemultiplexer):
    http_user_and_session = True

    consumers = {
        'testmodel': TestModelResourceBinding.consumer
    }

channel_routing = [
    route_class(TestDemultiplexer)
]