def test_host_whitelist_failure(self):
        application = Application()

        # failure bad host with localhost provided as Host
        with ManagedServerLoop(application, host=["bad_host"]) as server:
            self.check_http_blocked_socket_blocked(server)

        with ManagedServerLoop(application, host=["bad_host:5006"]) as server:
            self.check_http_blocked_socket_blocked(server)

        # failure bad host with localhost expected and bad_host provided
        with ManagedServerLoop(application, port=5006) as server:
            self.check_http_blocked_socket_blocked(server, host="bad_host")

        with ManagedServerLoop(application, port=5006) as server:
            self.check_http_blocked_socket_blocked(server, host="bad_host:5006")

        # failure good host, bad port
        with ManagedServerLoop(application, host=["localhost:80"]) as server:
            self.check_http_blocked_socket_blocked(server)

        # failure good host, bad default port
        with ManagedServerLoop(application, host=["localhost"]) as server:
            self.check_http_blocked_socket_blocked(server)

        # failure with custom port
        with ManagedServerLoop(application, port=8080, host=["localhost:8081"]) as server:
            self.check_http_blocked_socket_blocked(server)

        # failure with implicit port 80 in Host when server is on another port
        with ManagedServerLoop(application, port=5006, host=["example.com:5007"]) as server:
            self.check_http_blocked_socket_blocked(server, host="example.com")
示例#2
0
    def test_allow_websocket_origin(self):
        application = Application()

        # allow an origin that's an allowed host but not an extra origin
        with ManagedServerLoop(application,
                               host=None,
                               allow_websocket_origin=["example.com"
                                                       ]) as server:
            self.check_http_ok_socket_ok(server, origin=url(server))

        # allow good host and good origin
        with ManagedServerLoop(application,
                               host=None,
                               allow_websocket_origin=["example.com"
                                                       ]) as server:
            self.check_http_ok_socket_ok(server,
                                         origin="http://example.com:80")

        # allow good host and good origin with port
        with ManagedServerLoop(application,
                               host=None,
                               allow_websocket_origin=["example.com:8080"
                                                       ]) as server:
            self.check_http_ok_socket_ok(server,
                                         origin="http://example.com:8080")

        # block non-Host origins by default even if no extra origins specified
        with ManagedServerLoop(application, host=None) as server:
            self.check_http_ok_socket_blocked(server,
                                              origin="http://example.com:80")

        # block on a garbage Origin header
        with ManagedServerLoop(application, host=None) as server:
            self.check_http_ok_socket_blocked(server,
                                              origin="hsdf:::///%#^$#:8080")

        # block good host and bad origin
        with ManagedServerLoop(application,
                               host=None,
                               allow_websocket_origin=["example.com"
                                                       ]) as server:
            self.check_http_ok_socket_blocked(server,
                                              origin="http://foobar.com:80")

        # block good host and bad origin port
        with ManagedServerLoop(application,
                               host=None,
                               allow_websocket_origin=["example.com:8080"
                                                       ]) as server:
            self.check_http_ok_socket_blocked(server,
                                              origin="http://example.com:8081")

        # block on bad host even though the bad host is an allowed origin
        with ManagedServerLoop(application,
                               host=["bad_host"],
                               allow_websocket_origin=["bad_host"]) as server:
            self.check_http_blocked_socket_blocked(server,
                                                   origin="http://bad_host:80")
    def test_pull_document(self):
        application = Application()

        def add_roots(doc):
            doc.add_root(AnotherModelInTestClientServer(bar=43))
            doc.add_root(SomeModelInTestClientServer(foo=42))

        handler = FunctionHandler(add_roots)
        application.add(handler)

        with ManagedServerLoop(application) as server:
            client_session = pull_session(session_id='test_pull_document',
                                          url=url(server),
                                          io_loop=server.io_loop)
            assert len(client_session.document.roots) == 2

            server_session = server.get_session('/', client_session.id)
            assert len(server_session.document.roots) == 2

            results = {}
            for r in server_session.document.roots:
                if hasattr(r, 'foo'):
                    results['foo'] = r.foo
                if hasattr(r, 'bar'):
                    results['bar'] = r.bar
            assert results['foo'] == 42
            assert results['bar'] == 43

            client_session.close()
            client_session.loop_until_closed(suppress_warning=True)
            assert not client_session.connected
    def test_client_session_next_tick_async(self):
        application = Application()
        with ManagedServerLoop(application) as server:
            doc = document.Document()

            client_session = push_session(
                doc,
                session_id='test_client_session_next_tick_async',
                url=url(server),
                io_loop=server.io_loop)

            result = DictModel()
            doc.add_root(result)

            @gen.coroutine
            def cb():
                result.values['a'] = 0
                result.values['b'] = yield self.async_value(1)
                result.values['c'] = yield self.async_value(2)
                result.values['d'] = yield self.async_value(3)
                result.values['e'] = yield self.async_value(4)
                client_session.close()
                raise gen.Return(5)

            cb_id = doc.add_next_tick_callback(cb)

            client_session.loop_until_closed(suppress_warning=True)

            with pytest.raises(ValueError) as exc:
                doc.remove_next_tick_callback(cb_id)
            assert 'already removed' in repr(exc.value)

            assert dict(a=0, b=1, c=2, d=3, e=4) == result.values
示例#5
0
    def test_client_session_next_tick_async_added_before_push(self):
        application = Application()
        with ManagedServerLoop(application) as server:
            doc = document.Document()

            result = DictModel()
            doc.add_root(result)

            @gen.coroutine
            def cb():
                result.values['a'] = 0
                result.values['b'] = yield self.async_value(1)
                result.values['c'] = yield self.async_value(2)
                result.values['d'] = yield self.async_value(3)
                result.values['e'] = yield self.async_value(4)
                client_session.close()
                raise gen.Return(5)

            doc.add_next_tick_callback(cb)

            client_session = push_session(
                doc,
                session_id='test_client_session_next_tick_async',
                url=url(server),
                io_loop=server.io_loop)

            client_session.loop_until_closed()

            with (self.assertRaises(ValueError)) as manager:
                doc.remove_next_tick_callback(cb)
            self.assertTrue('already removed' in repr(manager.exception))

            self.assertDictEqual(dict(a=0, b=1, c=2, d=3, e=4), result.values)
示例#6
0
    def test_push_document(self):
        application = Application()
        with ManagedServerLoop(application) as server:
            doc = document.Document()
            doc.add_root(AnotherModelInTestClientServer(bar=43))
            doc.add_root(SomeModelInTestClientServer(foo=42))

            client_session = push_session(doc,
                                          session_id='test_push_document',
                                          url=url(server),
                                          io_loop=server.io_loop)

            assert client_session.document == doc
            assert len(client_session.document.roots) == 2

            server_session = server.get_session('/', client_session.id)

            assert len(server_session.document.roots) == 2
            results = {}
            for r in server_session.document.roots:
                if hasattr(r, 'foo'):
                    results['foo'] = r.foo
                if hasattr(r, 'bar'):
                    results['bar'] = r.bar
            assert results['foo'] == 42
            assert results['bar'] == 43

            client_session.close()
            client_session.loop_until_closed()
            assert not client_session.connected
    def test_server_session_next_tick_async(self):
        application = Application()
        with ManagedServerLoop(application) as server:
            doc = document.Document()
            doc.add_root(DictModel())

            client_session = push_session(doc,
                                          session_id='test_server_session_next_tick_async',
                                          url=url(server),
                                          io_loop=server.io_loop)
            server_session = server.get_session('/', client_session.id)

            result = next(iter(server_session.document.roots))

            @gen.coroutine
            def cb():
                # we're testing that we can modify the doc and be
                # "inside" the document lock
                result.values['a'] = 0
                result.values['b'] = yield self.async_value(1)
                result.values['c'] = yield self.async_value(2)
                result.values['d'] = yield self.async_value(3)
                result.values['e'] = yield self.async_value(4)
                client_session.close()
                raise gen.Return(5)

            server_session.document.add_next_tick_callback(cb)

            client_session.loop_until_closed()

            with (self.assertRaises(ValueError)) as manager:
                server_session.document.remove_next_tick_callback(cb)
            self.assertTrue('already removed' in repr(manager.exception))

            self.assertDictEqual(dict(a=0, b=1, c=2, d=3, e=4), result.values)
    def test_client_session_periodic_async_added_before_push(self):
        application = Application()
        with ManagedServerLoop(application) as server:
            doc = document.Document()

            result = DictModel()
            doc.add_root(result)

            @gen.coroutine
            def cb():
                result.values['a'] = 0
                result.values['b'] = yield self.async_value(1)
                result.values['c'] = yield self.async_value(2)
                result.values['d'] = yield self.async_value(3)
                result.values['e'] = yield self.async_value(4)
                client_session.close()
                raise gen.Return(5)

            cb_id = doc.add_periodic_callback(cb, 10)

            client_session = push_session(
                doc,
                session_id='test_client_session_periodic_async',
                url=url(server),
                io_loop=server.io_loop)

            client_session.loop_until_closed(suppress_warning=True)

            doc.remove_periodic_callback(cb_id)

            assert dict(a=0, b=1, c=2, d=3, e=4) == result.values
    def test_server_session_periodic_async(self):
        application = Application()
        with ManagedServerLoop(application) as server:
            doc = document.Document()
            doc.add_root(DictModel())

            client_session = push_session(
                doc,
                session_id='test_server_session_periodic_async',
                url=url(server),
                io_loop=server.io_loop)
            server_session = server.get_session('/', client_session.id)

            result = next(iter(server_session.document.roots))

            @gen.coroutine
            def cb():
                # we're testing that we can modify the doc and be
                # "inside" the document lock
                result.values['a'] = 0
                result.values['b'] = yield self.async_value(1)
                result.values['c'] = yield self.async_value(2)
                result.values['d'] = yield self.async_value(3)
                result.values['e'] = yield self.async_value(4)
                client_session.close()
                raise gen.Return(5)

            cb_id = server_session.document.add_periodic_callback(cb, 10)

            client_session.loop_until_closed(suppress_warning=True)

            server_session.document.remove_periodic_callback(cb_id)

            assert dict(a=0, b=1, c=2, d=3, e=4) == result.values
    def test_ping(self):
        application = Application()
        with ManagedServerLoop(application,
                               keep_alive_milliseconds=0) as server:
            session = ClientSession(session_id='test_ping',
                                    websocket_url=ws_url(server),
                                    io_loop=server.io_loop)
            session.connect()
            assert session.connected
            assert session.document is None

            connection = next(iter(server._tornado._clients))
            expected_pong = connection._ping_count
            server._tornado._keep_alive()  # send ping
            session.force_roundtrip()

            assert expected_pong == connection._socket.latest_pong

            # check that each ping increments by 1
            server._tornado._keep_alive()
            session.force_roundtrip()

            assert (expected_pong + 1) == connection._socket.latest_pong

            session.close()
            session.loop_until_closed(suppress_warning=True)
            assert not session.connected
    def test_allow_websocket_origin(self):
        application = Application()

        # allow good origin
        with ManagedServerLoop(application, allow_websocket_origin=["example.com"]) as server:
            self.check_http_ok_socket_ok(server, origin="http://example.com:80")

        # allow good origin with port
        with ManagedServerLoop(application, allow_websocket_origin=["example.com:8080"]) as server:
            self.check_http_ok_socket_ok(server, origin="http://example.com:8080")

        # allow good origin header with an implicit 80
        with ManagedServerLoop(application, allow_websocket_origin=["example.com"]) as server:
            self.check_http_ok_socket_ok(server, origin="http://example.com")

        # block non-Host origins by default even if no extra origins specified
        with ManagedServerLoop(application) as server:
            self.check_http_ok_socket_blocked(server, origin="http://example.com:80")

        # block on a garbage Origin header
        with ManagedServerLoop(application) as server:
            self.check_http_ok_socket_blocked(server, origin="hsdf:::///%#^$#:8080")

        # block bad origin
        with ManagedServerLoop(application, allow_websocket_origin=["example.com"]) as server:
            self.check_http_ok_socket_blocked(server, origin="http://foobar.com:80")

        # block bad origin port
        with ManagedServerLoop(application, allow_websocket_origin=["example.com:8080"]) as server:
            self.check_http_ok_socket_blocked(server, origin="http://example.com:8081")
def test_unit_spec_changes_do_not_boomerang(monkeypatch):
    application = Application()
    with ManagedServerLoop(application) as server:
        doc = document.Document()
        client_root = UnitsSpecModel()
        doc.add_root(client_root)

        client_session = push_session(doc,
                                      session_id='test_unit_spec_changes_do_not_boomerang',
                                      url=url(server),
                                      io_loop=server.io_loop)
        server_session = server.get_session('/', client_session.id)

        assert len(server_session.document.roots) == 1
        server_root = next(iter(server_session.document.roots))

        assert client_root.distance == 42
        assert server_root.angle == 0

        def change_to(new_distance, new_angle):
            got_angry = {}
            got_angry['result'] = None
            # trap any boomerang
            def get_angry(message):
                got_angry['result'] = message
            monkeypatch.setattr(client_session, '_handle_patch', get_angry)

            server_previous_distance = server_root.distance
            server_previous_angle = server_root.angle

            # Now modify the client document
            client_root.distance = new_distance
            client_root.angle = new_angle

            # wait until server side change made ... but we may not have the
            # boomerang yet
            def server_change_made():
                return server_root.distance != server_previous_distance and \
                    server_root.angle != server_previous_angle
            client_session._connection._loop_until(server_change_made)

            # force a round trip to be sure we get the boomerang if we're going to
            client_session.force_roundtrip()

            assert got_angry['result'] is None

        change_to(57, 1)
        change_to({ 'value' : 58 }, { 'value' : 2 })
        change_to({ 'field' : 'foo' }, { 'field' : 'bar' })
        change_to({ 'value' : 59, 'units' : 'screen' }, { 'value' : 30, 'units' : 'deg' })

        client_session.close()
        client_session.loop_until_closed()
        assert not client_session.connected
        server.unlisten() # clean up so next test can run
 def test_minimal_connect_and_disconnect(self):
     application = Application()
     with ManagedServerLoop(application) as server:
         # we don't have to start the server because it
         # uses the same main loop as the client, so
         # if we start either one it starts both
         session = ClientSession(session_id='test_minimal_connect_and_disconnect',
                                 io_loop = server.io_loop,
                                 websocket_url = ws_url(server))
         session.connect()
         assert session.connected
    def test_client_changes_go_to_server(self):
        application = Application()
        with ManagedServerLoop(application) as server:
            doc = document.Document()
            client_root = SomeModelInTestClientServer(foo=42)

            client_session = push_session(
                doc,
                session_id='test_client_changes_go_to_server',
                url=url(server),
                io_loop=server.io_loop)
            server_session = server.get_session('/', client_session.id)

            assert len(server_session.document.roots) == 0

            doc.add_root(client_root)
            client_session.force_roundtrip(
            )  # be sure events have been handled on server

            assert len(server_session.document.roots) == 1
            server_root = next(iter(server_session.document.roots))

            assert client_root.foo == 42
            assert server_root.foo == 42

            # Now try setting title
            assert server_session.document.title == document.DEFAULT_TITLE
            doc.title = "Client Title"
            client_session.force_roundtrip(
            )  # be sure events have been handled on server

            assert server_session.document.title == "Client Title"

            # Now modify an attribute on a client model
            client_root.foo = 57

            # there is no great way to block until the server
            # has applied changes, since patches are sent
            # asynchronously. We use internal _loop_until API.
            def server_change_made():
                return server_root.foo == 57

            client_session._connection._loop_until(server_change_made)
            assert server_root.foo == 57

            doc.remove_root(client_root)
            client_session.force_roundtrip(
            )  # be sure events have been handled on server
            assert len(server_session.document.roots) == 0

            client_session.close()
            client_session.loop_until_closed(suppress_warning=True)
            assert not client_session.connected
示例#15
0
    def test_host_whitelist_success(self):
        application = Application()

        # succeed no host value with defaults
        with ManagedServerLoop(application, host=None) as server:
            self.check_http_ok_socket_ok(server)

        # succeed no host value with port
        with ManagedServerLoop(application, port=8080, host=None) as server:
            self.check_http_ok_socket_ok(server)

        # succeed matching host value
        with ManagedServerLoop(application, port=8080,
                               host=["localhost:8080"]) as server:
            self.check_http_ok_socket_ok(server)

        # succeed matching host value one of multiple
        with ManagedServerLoop(application,
                               port=8080,
                               host=["bad_host", "localhost:8080"]) as server:
            self.check_http_ok_socket_ok(server)
示例#16
0
    def test_host_whitelist_success(self):
        application = Application()

        # succeed no host value with defaults
        with ManagedServerLoop(application, host=None) as server:
            self.check_http_ok_socket_ok(server)

        # succeed no host value with port
        with ManagedServerLoop(application, port=8080, host=None) as server:
            self.check_http_ok_socket_ok(server)

        # succeed matching host value (localhost)
        with ManagedServerLoop(application, port=8080,
                               host=["localhost:8080"]) as server:
            self.check_http_ok_socket_ok(server)

        # succeed matching host value (not localhost)
        with ManagedServerLoop(application,
                               port=8080,
                               host=["example.com:8080"]) as server:
            self.check_http_ok_socket_ok(server, host="example.com:8080")

        # succeed matching host value one of multiple
        with ManagedServerLoop(application,
                               port=8080,
                               host=["bad_host", "localhost:8080"]) as server:
            self.check_http_ok_socket_ok(server)

        # succeed matching host value with implicit port 80 (note
        # that the server is in fact on 8080, as if we were behind
        # a reverse proxy)
        with ManagedServerLoop(application, port=8080,
                               host=["example.com:80"]) as server:
            self.check_http_ok_socket_ok(server, host="example.com")
def test_server_changes_do_not_boomerang(monkeypatch):
    application = Application()
    with ManagedServerLoop(application) as server:
        doc = document.Document()
        client_root = SomeModelInTestClientServer(foo=42)
        doc.add_root(client_root)

        client_session = push_session(
            doc,
            session_id='test_server_changes_do_not_boomerang',
            url=url(server),
            io_loop=server.io_loop)
        server_session = server.get_session('/', client_session.id)

        assert len(server_session.document.roots) == 1
        server_root = next(iter(server_session.document.roots))

        assert client_root.foo == 42
        assert server_root.foo == 42

        got_angry = {}
        got_angry['result'] = None

        # trap any boomerang
        def get_angry(message, connection):
            got_angry['result'] = message

        monkeypatch.setattr(server_session, '_handle_patch', get_angry)

        # Now modify the server document
        def do_set_foo_property():
            server_root.foo = 57

        server_session.with_document_locked(do_set_foo_property)

        # there is no great way to block until the server
        # has applied changes, since patches are sent
        # asynchronously. We use internal _loop_until API.
        def client_change_made():
            return client_root.foo == 57

        client_session._connection._loop_until(client_change_made)
        assert client_root.foo == 57

        # force a round trip to be sure we get the boomerang if we're going to
        client_session.force_roundtrip()

        assert got_angry['result'] is None

        client_session.close()
        client_session.loop_until_closed(suppress_warning=True)
        assert not client_session.connected
示例#18
0
    def test_host_whitelist_failure(self):
        application = Application()

        # failure bad host
        with ManagedServerLoop(application, host=["bad_host"]) as server:
            self.check_http_blocked_socket_blocked(server)

        with ManagedServerLoop(application, host=["bad_host:5006"]) as server:
            self.check_http_blocked_socket_blocked(server)

        # failure good host, bad port
        with ManagedServerLoop(application, host=["localhost:80"]) as server:
            self.check_http_blocked_socket_blocked(server)

        # failure good host, bad default port
        with ManagedServerLoop(application, host=["localhost"]) as server:
            self.check_http_blocked_socket_blocked(server)

        # failure with custom port
        with ManagedServerLoop(application, port=8080,
                               host=["localhost:8081"]) as server:
            self.check_http_blocked_socket_blocked(server)
def test_client_changes_do_not_boomerang(monkeypatch):
    application = Application()
    with ManagedServerLoop(application) as server:
        doc = document.Document()
        client_root = SomeModelInTestClientServer(foo=42)
        doc.add_root(client_root)

        client_session = push_session(
            doc,
            session_id='test_client_changes_do_not_boomerang',
            url=url(server),
            io_loop=server.io_loop)
        server_session = server.get_session('/', client_session.id)

        assert len(server_session.document.roots) == 1
        server_root = next(iter(server_session.document.roots))

        assert client_root.foo == 42
        assert server_root.foo == 42

        got_angry = {}
        got_angry['result'] = None

        # trap any boomerang
        def get_angry(message):
            got_angry['result'] = message

        monkeypatch.setattr(client_session, '_handle_patch', get_angry)

        # Now modify the client document
        client_root.foo = 57

        # wait until server side change made ... but we may not have the
        # boomerang yet
        def server_change_made():
            return server_root.foo == 57

        client_session._connection._loop_until(server_change_made)
        assert server_root.foo == 57

        # force a round trip to be sure we get the boomerang if we're going to
        client_session.force_roundtrip()

        assert got_angry['result'] is None

        client_session.close()
        client_session.loop_until_closed(suppress_warning=True)
        assert not client_session.connected
        server.unlisten()  # clean up so next test can run
 def test_disconnect_on_error(self):
     application = Application()
     with ManagedServerLoop(application) as server:
         session = ClientSession(session_id='test_disconnect_on_error',
                                 websocket_url=ws_url(server),
                                 io_loop=server.io_loop)
         session.connect()
         assert session.connected
         # send a bogus message using private fields
         session._connection._socket.write_message(b"xx", binary=True)
         # connection should now close on the server side
         # and the client loop should end
         session.loop_until_closed(suppress_warning=True)
         assert not session.connected
         session.close()
         session.loop_until_closed(suppress_warning=True)
         assert not session.connected
    def test_connect_with_prefix(self):
        application = Application()
        with ManagedServerLoop(application, prefix="foo") as server:
            # we don't have to start the server because it
            # uses the same main loop as the client, so
            # if we start either one it starts both
            session = ClientSession(io_loop=server.io_loop,
                                    websocket_url=ws_url(server, "/foo"))
            session.connect()
            assert session.connected
            session.close()
            session.loop_until_closed(suppress_warning=True)

            session = ClientSession(io_loop=server.io_loop,
                                    websocket_url=ws_url(server))
            session.connect()
            assert not session.connected
            session.close()
            session.loop_until_closed(suppress_warning=True)
    def test_request_server_info(self):
        application = Application()
        with ManagedServerLoop(application) as server:
            session = ClientSession(session_id='test_request_server_info',
                                    websocket_url=ws_url(server),
                                    io_loop=server.io_loop)
            session.connect()
            assert session.connected
            assert session.document is None

            info = session.request_server_info()

            from bokeh import __version__

            assert info['version_info']['bokeh'] == __version__
            assert info['version_info']['server'] == __version__

            session.close()
            session.loop_until_closed(suppress_warning=True)
            assert not session.connected
    def test_io_push_to_server(self):
        from bokeh.io import output_server, push, curdoc, reset_output
        application = Application()
        with ManagedServerLoop(application) as server:
            reset_output()
            doc = curdoc()
            doc.clear()

            client_root = SomeModelInTestClientServer(foo=42)

            session_id = 'test_io_push_to_server'
            output_server(session_id=session_id,
                          url=("http://localhost:%d/" % server.port))

            doc.add_root(client_root)
            push(io_loop=server.io_loop)

            server_session = server.get_session('/', session_id)

            print(repr(server_session.document.roots))

            assert len(server_session.document.roots) == 1
            server_root = next(iter(server_session.document.roots))

            assert client_root.foo == 42
            assert server_root.foo == 42

            # Now modify the client document and push
            client_root.foo = 57
            push(io_loop=server.io_loop)
            server_root = next(iter(server_session.document.roots))
            assert server_root.foo == 57

            # Remove a root and push
            doc.remove_root(client_root)
            push(io_loop=server.io_loop)
            assert len(server_session.document.roots) == 0

            # Clean up global IO state
            reset_output()
    def test_allow_websocket_origin(self):
        application = Application()

        # allow good origin
        with ManagedServerLoop(application,
                               allow_websocket_origin=["example.com"
                                                       ]) as server:
            self.check_http_ok_socket_ok(server,
                                         origin="http://example.com:80")

        # allow good origin from environment variable
        with ManagedServerLoop(application) as server:
            os.environ["BOKEH_ALLOW_WS_ORIGIN"] = "example.com"
            self.check_http_ok_socket_ok(server,
                                         origin="http://example.com:80")
            del os.environ["BOKEH_ALLOW_WS_ORIGIN"]

        # allow good origin with port
        with ManagedServerLoop(application,
                               allow_websocket_origin=["example.com:8080"
                                                       ]) as server:
            self.check_http_ok_socket_ok(server,
                                         origin="http://example.com:8080")

        # allow good origin with port from environment variable
        with ManagedServerLoop(application) as server:
            os.environ["BOKEH_ALLOW_WS_ORIGIN"] = "example.com:8080"
            self.check_http_ok_socket_ok(server,
                                         origin="http://example.com:8080")
            del os.environ["BOKEH_ALLOW_WS_ORIGIN"]

        # allow good origin header with an implicit 80
        with ManagedServerLoop(application,
                               allow_websocket_origin=["example.com"
                                                       ]) as server:
            self.check_http_ok_socket_ok(server, origin="http://example.com")

        # allow good origin header with an implicit 80
        with ManagedServerLoop(application) as server:
            os.environ["BOKEH_ALLOW_WS_ORIGIN"] = "example.com"
            self.check_http_ok_socket_ok(server, origin="http://example.com")
            del os.environ["BOKEH_ALLOW_WS_ORIGIN"]

        # block non-Host origins by default even if no extra origins specified
        with ManagedServerLoop(application) as server:
            self.check_http_ok_socket_blocked(server,
                                              origin="http://example.com:80")

        # block on a garbage Origin header
        with ManagedServerLoop(application) as server:
            self.check_http_ok_socket_blocked(server,
                                              origin="hsdf:::///%#^$#:8080")

        # block bad origin
        with ManagedServerLoop(application,
                               allow_websocket_origin=["example.com"
                                                       ]) as server:
            self.check_http_ok_socket_blocked(server,
                                              origin="http://foobar.com:80")

        # block bad origin from environment variable
        with ManagedServerLoop(application) as server:
            os.environ["BOKEH_ALLOW_WS_ORIGIN"] = "example.com"
            self.check_http_ok_socket_blocked(server,
                                              origin="http://foobar.com:80")
            del os.environ["BOKEH_ALLOW_WS_ORIGIN"]

        # block bad origin port
        with ManagedServerLoop(application,
                               allow_websocket_origin=["example.com:8080"
                                                       ]) as server:
            self.check_http_ok_socket_blocked(server,
                                              origin="http://example.com:8081")

        # block bad origin port from environment variable
        with ManagedServerLoop(application) as server:
            os.environ["BOKEH_ALLOW_WS_ORIGIN"] = "example.com:8080"
            self.check_http_ok_socket_blocked(server,
                                              origin="http://example.com:8081")
            del os.environ["BOKEH_ALLOW_WS_ORIGIN"]
    def test_lots_of_concurrent_messages(self):
        application = Application()

        def setup_stuff(doc):
            m1 = AnotherModelInTestClientServer(bar=43, name='m1')
            m2 = SomeModelInTestClientServer(foo=42, name='m2')
            m3 = SomeModelInTestClientServer(foo=68, name='m3')
            doc.add_root(m1)
            doc.add_root(m2)
            doc.add_root(m3)

            def timeout1():
                m1.bar += 1

            timeout1_cb_id = doc.add_timeout_callback(timeout1, 1)

            def timeout2():
                m2.foo += 1

            timeout2_cb_id = doc.add_timeout_callback(timeout2, 3)

            def periodic1():
                m1.bar += 1
                doc.remove_timeout_callback(timeout1_cb_id)
                doc.add_timeout_callback(timeout1, m1.bar % 7)

            doc.add_periodic_callback(periodic1, 3)

            def periodic2():
                m2.foo += 1
                doc.remove_timeout_callback(timeout2_cb_id)
                doc.add_timeout_callback(timeout2, m2.foo % 7)

            doc.add_periodic_callback(periodic2, 1)

            def server_on_change(event):
                if isinstance(event, ModelChangedEvent) and event.model is m3:
                    return
                m3.foo += 1

            doc.on_change(server_on_change)

        handler = FunctionHandler(setup_stuff)
        application.add(handler)

        # keep_alive_milliseconds=1 sends pings as fast as the OS will let us
        with ManagedServerLoop(application,
                               keep_alive_milliseconds=1) as server:
            session = pull_session(
                session_id='test_lots_of_concurrent_messages',
                url=url(server),
                io_loop=server.io_loop)
            assert session.connected

            server_session = server.get_session('/', session.id)

            def client_timeout():
                m = session.document.roots[0]
                m.name = m.name[::-1]

            cb_id = session.document.add_timeout_callback(client_timeout, 3)

            def client_periodic():
                m = session.document.roots[1]
                m.name = m.name[::-1]
                session.document.remove_timeout_callback(cb_id)
                session.document.add_timeout_callback(client_timeout, 3)

            session.document.add_periodic_callback(client_periodic, 1)

            result = {}

            def end_test():
                result['connected'] = session.connected
                result[
                    'server_connection_count'] = server_session.connection_count
                result['server_close_code'] = next(
                    iter(server._tornado._clients))._socket.close_code
                result['doc'] = session.document.to_json()
                session.close()

            # making this longer is more likely to trigger bugs, but it also
            # makes the test take however much time you put here
            session.document.add_timeout_callback(end_test, 250)

            def client_on_change(event):
                if not isinstance(event, TitleChangedEvent):
                    session.document.title = session.document.title[::-1]

            session.document.on_change(client_on_change)

            session.loop_until_closed(suppress_warning=True)

            assert not session.connected

            # we should have still been connected at the end,
            # if we didn't have any crazy protocol errors
            assert 'connected' in result
            assert result['connected']

            # server should also still have been connected
            assert result['server_connection_count'] == 1
            assert result['server_close_code'] is None
    def test_server_changes_go_to_client(self):
        application = Application()
        with ManagedServerLoop(application) as server:
            doc = document.Document()

            client_session = push_session(
                doc,
                session_id='test_server_changes_go_to_client',
                url=url(server),
                io_loop=server.io_loop)
            server_session = server.get_session('/', client_session.id)

            assert len(client_session.document.roots) == 0
            server_root = SomeModelInTestClientServer(foo=42)

            def do_add_server_root():
                server_session.document.add_root(server_root)

            server_session.with_document_locked(do_add_server_root)

            def client_has_root():
                return len(doc.roots) > 0

            client_session._connection._loop_until(client_has_root)
            client_root = next(iter(client_session.document.roots))

            assert client_root.foo == 42
            assert server_root.foo == 42

            # Now try setting title on server side
            def do_set_server_title():
                server_session.document.title = "Server Title"

            server_session.with_document_locked(do_set_server_title)

            def client_title_set():
                return client_session.document.title != document.DEFAULT_TITLE

            client_session._connection._loop_until(client_title_set)

            assert client_session.document.title == "Server Title"

            # Now modify a model within the server document
            def do_set_property_on_server():
                server_root.foo = 57

            server_session.with_document_locked(do_set_property_on_server)

            # there is no great way to block until the server
            # has applied changes, since patches are sent
            # asynchronously. We use internal _loop_until API.
            def client_change_made():
                return client_root.foo == 57

            client_session._connection._loop_until(client_change_made)
            assert client_root.foo == 57

            def do_remove_server_root():
                server_session.document.remove_root(server_root)

            server_session.with_document_locked(do_remove_server_root)

            def client_lacks_root():
                return len(doc.roots) == 0

            client_session._connection._loop_until(client_lacks_root)
            assert len(client_session.document.roots) == 0

            client_session.close()
            client_session.loop_until_closed(suppress_warning=True)
            assert not client_session.connected