def test_websocket_with_map(self):
"""
Speaking WebSocket when the connection is made will make UniSocket
create a new WebSocket protocol and send the data to it.
"""
t = StringTransport()
class MyFakeWebSocket(Protocol):
"""
A fake WebSocket factory which just echos data back.
"""
def dataReceived(self, data):
self.transport.write(data)
fake_websocket = Factory.forProtocol(MyFakeWebSocket)
websocket_map = OrderedDict({u"baz": None})
websocket_map["ws"] = fake_websocket
f = UniSocketServerFactory(websocket_factory_map=websocket_map)
p = f.buildProtocol(None)
p.makeConnection(t)
t.protocol = p
self.assertTrue(t.connected)
p.dataReceived(b'GET /ws HTTP/1.1\r\nConnection: close\r\n\r\n')
self.assertTrue(t.connected)
self.assertEqual(t.value(),
b'GET /ws HTTP/1.1\r\nConnection: close\r\n\r\n')
def test_rawsocket_with_factory(self):
"""
Speaking RawSocket when the connection is made will make UniSocket
create a new RawSocket protocol and send the data to it.
"""
t = StringTransport()
class MyFakeRawSocket(Protocol):
"""
A fake RawSocket factory which just echos data back.
"""
def dataReceived(self, data):
self.transport.write(data)
fake_rawsocket = Factory.forProtocol(MyFakeRawSocket)
f = UniSocketServerFactory(rawsocket_factory=fake_rawsocket)
p = f.buildProtocol(None)
p.makeConnection(t)
t.protocol = p
self.assertTrue(t.connected)
p.dataReceived(b'\x7F0000000')
p.dataReceived(b'moredata')
self.assertTrue(t.connected)
self.assertEqual(t.value(), b'\x7F0000000moredata')
def test_rawsocket_with_factory(self):
"""
Speaking RawSocket when the connection is made will make UniSocket
create a new RawSocket protocol and send the data to it.
"""
t = StringTransport()
class MyFakeRawSocket(Protocol):
"""
A fake RawSocket factory which just echos data back.
"""
def dataReceived(self, data):
self.transport.write(data)
fake_rawsocket = Factory.forProtocol(MyFakeRawSocket)
f = UniSocketServerFactory(rawsocket_factory=fake_rawsocket)
p = f.buildProtocol(None)
p.makeConnection(t)
t.protocol = p
self.assertTrue(t.connected)
p.dataReceived(b'\x7F0000000')
p.dataReceived(b'moredata')
self.assertTrue(t.connected)
self.assertEqual(t.value(), b'\x7F0000000moredata')
def test_websocket_with_map(self):
"""
Speaking WebSocket when the connection is made will make UniSocket
create a new WebSocket protocol and send the data to it.
"""
t = StringTransport()
class MyFakeWebSocket(Protocol):
"""
A fake WebSocket factory which just echos data back.
"""
def dataReceived(self, data):
self.transport.write(data)
fake_websocket = Factory.forProtocol(MyFakeWebSocket)
websocket_map = OrderedDict({u"baz": None})
websocket_map["ws"] = fake_websocket
f = UniSocketServerFactory(websocket_factory_map=websocket_map)
p = f.buildProtocol(None)
p.makeConnection(t)
t.protocol = p
self.assertTrue(t.connected)
p.dataReceived(b'GET /ws HTTP/1.1\r\nConnection: close\r\n\r\n')
self.assertTrue(t.connected)
self.assertEqual(t.value(),
b'GET /ws HTTP/1.1\r\nConnection: close\r\n\r\n')
def test_web_with_factory(self):
"""
Speaking HTTP will pass it down to the HTTP factory.
"""
t = StringTransport()
class MyResource(Resource):
isLeaf = True
def render_GET(self, request):
return b"hi!"
r = MyResource()
s = Site(r)
f = UniSocketServerFactory(web_factory=s)
p = f.buildProtocol(None)
p.makeConnection(t)
t.protocol = p
self.assertTrue(t.connected)
p.dataReceived(b'GET / HTTP/1.1\r\nConnection: close\r\n\r\n')
self.assertFalse(t.connected)
self.assertIn(b"hi!", t.value())
def test_web_with_factory(self):
"""
Speaking HTTP will pass it down to the HTTP factory.
"""
t = StringTransport()
class MyResource(Resource):
isLeaf = True
def render_GET(self, request):
return b"hi!"
r = MyResource()
s = Site(r)
f = UniSocketServerFactory(web_factory=s)
p = f.buildProtocol(None)
p.makeConnection(t)
t.protocol = p
self.assertTrue(t.connected)
p.dataReceived(b'GET / HTTP/1.1\r\nConnection: close\r\n\r\n')
self.assertFalse(t.connected)
self.assertIn(b"hi!", t.value())
def test_web_with_no_factory(self):
"""
Trying to speak HTTP without a factory will drop the connection.
"""
t = StringTransport()
f = UniSocketServerFactory()
p = f.buildProtocol(None)
p.makeConnection(t)
t.protocol = p
self.assertTrue(t.connected)
p.dataReceived(b'GET /foo HTTP/1.1\r\n\r\n')
self.assertFalse(t.connected)
def test_web_with_no_factory(self):
"""
Trying to speak HTTP without a factory will drop the connection.
"""
t = StringTransport()
f = UniSocketServerFactory()
p = f.buildProtocol(None)
p.makeConnection(t)
t.protocol = p
self.assertTrue(t.connected)
p.dataReceived(b'GET /foo HTTP/1.1\r\n\r\n')
self.assertFalse(t.connected)
def test_invalid_status_line(self):
"""
Not speaking RawSocket or MQTT but also not speaking a type of HTTP
will cause the connection to be dropped.
"""
t = StringTransport()
f = UniSocketServerFactory()
p = f.buildProtocol(None)
p.makeConnection(t)
t.protocol = p
self.assertTrue(t.connected)
p.dataReceived(b'this is not HTTP\r\n\r\n')
self.assertFalse(t.connected)
def test_invalid_status_line(self):
"""
Not speaking RawSocket but also not speaking a type of HTTP will cause
the connection to be dropped.
"""
t = StringTransport()
f = UniSocketServerFactory()
p = f.buildProtocol(None)
p.makeConnection(t)
t.protocol = p
self.assertTrue(t.connected)
p.dataReceived(b'this is not HTTP\r\n\r\n')
self.assertFalse(t.connected)
def test_rawsocket_with_no_factory(self):
"""
Trying to speak RawSocket with no RawSocket factory configured will
drop the connection.
"""
t = StringTransport()
f = UniSocketServerFactory()
p = f.buildProtocol(None)
p.makeConnection(t)
t.protocol = p
self.assertTrue(t.connected)
p.dataReceived(b'\x7F0000000')
self.assertFalse(t.connected)
def test_rawsocket_with_no_factory(self):
"""
Trying to speak RawSocket with no RawSocket factory configured will
drop the connection.
"""
t = StringTransport()
f = UniSocketServerFactory()
p = f.buildProtocol(None)
p.makeConnection(t)
t.protocol = p
self.assertTrue(t.connected)
p.dataReceived(b'\x7F0000000')
self.assertFalse(t.connected)
def test_websocket_with_no_map(self):
"""
A web request that matches no WebSocket
"""
t = StringTransport()
websocket_map = {u"x": None, u"y": None}
f = UniSocketServerFactory(websocket_factory_map=websocket_map)
p = f.buildProtocol(None)
p.makeConnection(t)
t.protocol = p
self.assertTrue(t.connected)
p.dataReceived(b'GET /ws HTTP/1.1\r\nConnection: close\r\n\r\n')
self.assertFalse(t.connected)
self.assertEqual(t.value(), b"")
def test_websocket_with_no_map(self):
"""
A web request that matches no WebSocket path will go to HTTP/1.1.
"""
t = StringTransport()
websocket_map = {u"x": None, u"y": None}
f = UniSocketServerFactory(websocket_factory_map=websocket_map)
p = f.buildProtocol(None)
p.makeConnection(t)
t.protocol = p
self.assertTrue(t.connected)
p.dataReceived(b'GET /ws HTTP/1.1\r\nConnection: close\r\n\r\n')
self.assertFalse(t.connected)
self.assertEqual(t.value(), b"")
def make_router():
"""
Make a router, and return it and a RawSocket factory.
"""
# create a router factory
router_factory = RouterFactory(None)
# create a router session factory
session_factory = RouterSessionFactory(router_factory)
# Create a new RawSocket factory
rawsocket_server_factory = WampRawSocketServerFactory(session_factory, {})
# Create a new UniSocket factory
server_factory = UniSocketServerFactory(rawsocket_factory=rawsocket_server_factory)
return router_factory, server_factory, session_factory
def make_router():
"""
Make a router, and return it and a RawSocket factory.
"""
# create a router factory
router_factory = RouterFactory(None, None)
# create a router session factory
session_factory = RouterSessionFactory(router_factory)
# Create a new WebSocket factory
websocket_server_factory = WampWebSocketServerFactory(session_factory, '.', {}, None)
# Create a new RawSocket factory
rawsocket_server_factory = WampRawSocketServerFactory(session_factory, {})
# Create a new UniSocket factory
server_factory = UniSocketServerFactory(websocket_factory_map={'/': websocket_server_factory},
rawsocket_factory=rawsocket_server_factory)
return router_factory, server_factory, session_factory
def _create_factory(self, create_paths=False, ignore=[]):
# Twisted (listening endpoint) transport factory
transport_factory = None
# Root Web service: only set (down below) when running a Web transport or
# a Universal transport with Web support
root_webservice = None
# standalone WAMP-RawSocket transport
#
if self._config['type'] == 'rawsocket':
transport_factory = WampRawSocketServerFactory(
self._worker.router_session_factory, self._config)
transport_factory.noisy = False
# standalone WAMP-WebSocket transport
#
elif self._config['type'] == 'websocket':
assert (self._templates)
transport_factory = WampWebSocketServerFactory(
self._worker.router_session_factory, self._cbdir, self._config,
self._templates)
transport_factory.noisy = False
# Flash-policy file server pseudo transport
#
elif self._config['type'] == 'flashpolicy':
transport_factory = FlashPolicyFactory(
self._config.get('allowed_domain', None),
self._config.get('allowed_ports', None))
# WebSocket testee pseudo transport
#
elif self._config['type'] == 'websocket.testee':
assert (self._templates)
transport_factory = WebSocketTesteeServerFactory(
self._config, self._templates)
# Stream testee pseudo transport
#
elif self._config['type'] == 'stream.testee':
transport_factory = StreamTesteeServerFactory()
# MQTT legacy adapter transport
#
elif self._config['type'] == 'mqtt':
transport_factory = WampMQTTServerFactory(
self._worker.router_session_factory, self._config,
self._worker._reactor)
transport_factory.noisy = False
# Twisted Web based transport
#
elif self._config['type'] == 'web':
assert (self._templates)
transport_factory, root_webservice = yield maybeDeferred(
self._create_web_factory, create_paths, ignore)
# Universal transport
#
elif self._config['type'] == 'universal':
if 'web' in self._config:
assert (self._templates)
web_factory, root_webservice = yield maybeDeferred(
self._create_web_factory, create_paths, ignore)
else:
web_factory, root_webservice = None, None
if 'rawsocket' in self._config:
rawsocket_factory = WampRawSocketServerFactory(
self._worker.router_session_factory,
self._config['rawsocket'])
rawsocket_factory.noisy = False
else:
rawsocket_factory = None
if 'mqtt' in self._config:
mqtt_factory = WampMQTTServerFactory(
self._worker.router_session_factory, self._config['mqtt'],
self._worker._reactor)
mqtt_factory.noisy = False
else:
mqtt_factory = None
if 'websocket' in self._config:
assert (self._templates)
websocket_factory_map = {}
for websocket_url_first_component, websocket_config in self._config[
'websocket'].items():
websocket_transport_factory = WampWebSocketServerFactory(
self._worker.router_session_factory, self._cbdir,
websocket_config, self._templates)
websocket_transport_factory.noisy = False
websocket_factory_map[
websocket_url_first_component] = websocket_transport_factory
self.log.debug(
'hooked up websocket factory on request URI {request_uri}',
request_uri=websocket_url_first_component)
else:
websocket_factory_map = None
transport_factory = UniSocketServerFactory(web_factory,
websocket_factory_map,
rawsocket_factory,
mqtt_factory)
# this is to allow subclasses to reuse this method
elif self._config['type'] in ignore:
pass
# unknown transport type
else:
# should not arrive here, since we did check_transport() in the beginning
raise Exception("logic error")
returnValue((transport_factory, root_webservice))
def start_router_transport(self, id, config, details=None):
"""
Start a transport on this router worker.
:param id: The ID of the transport to start.
:type id: str
:param config: The transport configuration.
:type config: dict
"""
self.log.debug("{name}.start_router_transport", name=self.__class__.__name__)
# prohibit starting a transport twice
#
if id in self.transports:
emsg = "Could not start transport: a transport with ID '{}' is already running (or starting)".format(id)
self.log.error(emsg)
raise ApplicationError(u'crossbar.error.already_running', emsg)
# check configuration
#
try:
checkconfig.check_router_transport(config)
except Exception as e:
emsg = "Invalid router transport configuration: {}".format(e)
self.log.error(emsg)
raise ApplicationError(u"crossbar.error.invalid_configuration", emsg)
else:
self.log.debug("Starting {ttype}-transport on router.", ttype=config['type'])
# standalone WAMP-RawSocket transport
#
if config['type'] == 'rawsocket':
transport_factory = WampRawSocketServerFactory(self._router_session_factory, config)
transport_factory.noisy = False
# standalone WAMP-WebSocket transport
#
elif config['type'] == 'websocket':
transport_factory = WampWebSocketServerFactory(self._router_session_factory, self.config.extra.cbdir, config, self._templates)
transport_factory.noisy = False
# Flash-policy file server pseudo transport
#
elif config['type'] == 'flashpolicy':
transport_factory = FlashPolicyFactory(config.get('allowed_domain', None), config.get('allowed_ports', None))
# WebSocket testee pseudo transport
#
elif config['type'] == 'websocket.testee':
transport_factory = WebSocketTesteeServerFactory(config, self._templates)
# Stream testee pseudo transport
#
elif config['type'] == 'stream.testee':
transport_factory = StreamTesteeServerFactory()
# Twisted Web based transport
#
elif config['type'] == 'web':
transport_factory = self._create_web_factory(config)
# Universal transport
#
elif config['type'] == 'universal':
if 'web' in config:
web_factory = self._create_web_factory(config['web'])
else:
web_factory = None
if 'rawsocket' in config:
rawsocket_factory = WampRawSocketServerFactory(self._router_session_factory, config['rawsocket'])
rawsocket_factory.noisy = False
else:
rawsocket_factory = None
if 'websocket' in config:
websocket_factory_map = {}
for websocket_url_first_component, websocket_config in config['websocket'].items():
websocket_transport_factory = WampWebSocketServerFactory(self._router_session_factory, self.config.extra.cbdir, websocket_config, self._templates)
websocket_transport_factory.noisy = False
websocket_factory_map[websocket_url_first_component] = websocket_transport_factory
self.log.debug('hooked up websocket factory on request URI {request_uri}', request_uri=websocket_url_first_component)
else:
websocket_factory_map = None
transport_factory = UniSocketServerFactory(web_factory, websocket_factory_map, rawsocket_factory)
# Unknown transport type
#
else:
# should not arrive here, since we did check_transport() in the beginning
raise Exception("logic error")
# create transport endpoint / listening port from transport factory
#
d = create_listening_port_from_config(config['endpoint'],
self.config.extra.cbdir,
transport_factory,
self._reactor,
self.log)
def ok(port):
self.transports[id] = RouterTransport(id, config, transport_factory, port)
self.log.debug("Router transport '{id}'' started and listening", id)
return
def fail(err):
emsg = "Cannot listen on transport endpoint: {log_failure}"
self.log.error(emsg, log_failure=err)
raise ApplicationError(u"crossbar.error.cannot_listen", emsg)
d.addCallbacks(ok, fail)
return d
