def connectionMade(self): WebSocketServerProtocol.connectionMade(self) self.LisaProtocolfactory = LisaProtocolFactory(self) if configuration['enable_secure_mode']: self.conn = reactor.connectSSL(configuration['lisa_url'], configuration['lisa_port'], self.LisaProtocolfactory, ClientAuthContextFactory()) else: self.conn = reactor.connectTCP(configuration['lisa_url'], configuration['lisa_port'], self.LisaProtocolfactory)
def onMessage(self, payload, isBinary): WebSocketServerProtocol.onMessage(self, payload, isBinary) if not isBinary: payload = payload.decode('string_escape') log.msg(payload, system="WebSocket DEBUG") msg = json.loads(payload) msg_type = msg['type'] if msg_type == 'auth': # В случае, если аутентифицируемся токеном вручную self.token = msg['token'] if not self.token: self.sendMessageJson({'exception': 'Not authorized', }) return if msg_type == 'call': self.process_call(msg) elif msg_type == 'broadcast': self.process_broadcast(msg) elif msg_type == 'sub': self.process_subscribe(msg) elif msg_type == 'unsub': self.process_unsubscribe(msg) else: self.sendMessageJson({ 'exception': 'Unknown message type: %s' % msg_type, 'object': msg, })
def onConnect(self, request): self.sendMessage("Server socket established") # Push an update for the new user. # This is inefficient so fix it if it becomes a problem. self.factory.pushUpdate() WebSocketServerProtocol.onConnect(self, request)
def connectionLost(self, reason): """ Programmed by: David Williams Description: Closes the connection when the connection is lost """ WebSocketServerProtocol.connectionLost(self, reason) print("Connection was closed.")
def connectionLost(self, reason): if DEBUG >= 1: print("WebSocket connection closed: {0}".format(reason)) WebSocketServerProtocol.connectionLost(self, reason) self.factory.unregister(self) name.pop(self.peer, None) self.sendUsers()
def sendMessage(self, payload, *args, **kwargs): """ Logs message """ logger.debug("Outgoing message for ({peer}) : {message}".format( peer=self.peer, message=payload)) WebSocketServerProtocol.sendMessage(self, payload, *args, **kwargs)
def connectionLost(self, reason): WebSocketServerProtocol.connectionLost(self, reason) self.factory.stats.trackOctetsWireIn(self.trafficStats.preopenIncomingOctetsWireLevel + \ self.trafficStats.incomingOctetsWireLevel) self.factory.stats.trackOctetsWireOut(self.trafficStats.preopenOutgoingOctetsWireLevel + \ self.trafficStats.outgoingOctetsWireLevel)
def setUp(self): self.factory = WebSocketServerFactory() self.factory.setProtocolOptions(trustXForwardedFor=2) self.proto = WebSocketServerProtocol() self.proto.transport = StringTransport() self.proto.factory = self.factory self.proto.failHandshake = Mock() self.proto._connectionMade()
def __init__(self, consumer=None): WebSocketServerProtocol.__init__(self) self.connected = False self.producer = None self.streaming = True self.consumer = consumer self.paused = False
def __init__(self, server): WebSocketServerProtocol.__init__(self) self.server = server self.recv = str() self.stat = str() self.player = None
def connectionLost(self, reason): WebSocketServerProtocol.connectionLost(self, reason) try: namespace = self.getNamespace() except NamespaceNotFound: pass else: namespace.client_disconnected(self)
def onOpen(self): print 'open:', self.user WebSocketServerProtocol.onOpen(self) self.factory.associate(self) if not self.user[fixed.detect_agent]: agents = [a.user[fixed.agent] for a in self.factory.agents()] print 'agents:', agents self.sendMessage(json.dumps({ fixed.agents: agents }))
def setUp(self): self.factory = WebSocketServerFactory() self.factory.setProtocolOptions( allowedOrigins=[u'127.0.0.1:*', u'*.example.com:*']) self.proto = WebSocketServerProtocol() self.proto.transport = StringTransport() self.proto.factory = self.factory self.proto.failHandshake = Mock() self.proto._connectionMade()
def onClose(self, wasClean, code, reason): """ Connect closed, cleanup """ # base logs WebSocketServerProtocol.onClose(self, wasClean, code, reason) if self.client is None: if self.debug: log.msg("RPIServerProtocol.onClose - No Client type") return self.client.onClose(wasClean, code, reason)
def __init__(self, board): WebSocketServerProtocol.__init__(self) self.log.debug = lambda *a, **kw: None self.board = board self.gpio_buffers = {} self.streaming = False self.inputs = [] self.active = [] self.start_time = time.time()*1000000 self.t = None self.base = 100000 self.window = 5000000
def __init__(self): global server, channels WebSocketServerProtocol.__init__(self) server = { "name": args["name"], "channels": channels } self.port = 0 self.plugged = False self.channel = "" self.creator = False self.maxclients = int(args["max_clients"]) self.protected = args["protected"]
def __init__(self, server): WebSocketServerProtocol.__init__(self) self.server = server self.address = str() self.recv = bytes() self.pendingStat = None self.stat = str() self.player = None self.blocked = bool() self.dcTimer = None
def __init__(self, server): WebSocketServerProtocol.__init__(self) self.server = server self.address = str() self.recv = bytearray() self.pendingStat = None self.stat = str() self.username = str() self.session = str() self.player = None self.blocked = bool() self.dcTimer = None self.maxConLifeTimer = None
def connectionLost(self, reason): global serial_port global serial_device global serial_baudrate if not self.connection_invalid: print "Disconnect Message Received" if serial_port != None: oldserial = serial_port serial_port = None serial_device = None serial_baudrate = None self.read_thread.stop() self.read_thread.join() oldserial.close() WebSocketServerProtocol.connectionLost(self, reason)
def __init__(self, server): WebSocketServerProtocol.__init__(self) self.server = server self.address = str() self.recv = str() self.pendingStat = None self.stat = str() self.player = None self.trustCount = int() self.blocked = bool() self.lastX = int() self.lastXOk = True self.dcTimer = None
def __init__(self, ws_endpoint_str, target_url, origin=None, headers=None, verbose=False, reactor=None): """ ws_endpoint_str: The proxied websocket endpoint string. target_url: should be a websocket URL, e.g. 'ws://127.0.0.1:9000' """ WebSocketServerProtocol.__init__(self) self.verbose = verbose self.ws_endpoint_str = ws_endpoint_str self.target_url = target_url self.origin = origin self.headers = headers self._queue = [] if self.reactor is None: from twisted.internet import reactor self.reactor = reactor
class WebSocketXForwardedFor(unittest.TestCase): """ Test that (only) a trusted X-Forwarded-For can replace the peer address. """ def setUp(self): self.factory = WebSocketServerFactory() self.factory.setProtocolOptions( trustXForwardedFor=2 ) self.proto = WebSocketServerProtocol() self.proto.transport = StringTransport() self.proto.factory = self.factory self.proto.failHandshake = Mock() self.proto._connectionMade() def tearDown(self): for call in [ self.proto.autoPingPendingCall, self.proto.autoPingTimeoutCall, self.proto.openHandshakeTimeoutCall, self.proto.closeHandshakeTimeoutCall, ]: if call is not None: call.cancel() def test_trusted_addresses(self): self.proto.data = b"\r\n".join([ b'GET /ws HTTP/1.1', b'Host: www.example.com', b'Origin: http://www.example.com', b'Sec-WebSocket-Version: 13', b'Sec-WebSocket-Extensions: permessage-deflate', b'Sec-WebSocket-Key: tXAxWFUqnhi86Ajj7dRY5g==', b'Connection: keep-alive, Upgrade', b'Upgrade: websocket', b'X-Forwarded-For: 1.2.3.4, 2.3.4.5, 111.222.33.44', b'\r\n', # last string doesn't get a \r\n from join() ]) self.proto.consumeData() self.assertEquals( self.proto.peer, "2.3.4.5", "The second address in X-Forwarded-For should have been picked as the peer address")
def __init__(self, server): WebSocketServerProtocol.__init__(self) self.server = server self.address = str() self.recv = bytearray() self.pendingStat = None self.stat = str() self.username = str() self.session = str() self.player = None self.blocked = bool() self.account = {} self.accountPriv = {} self.dcTimer = None #self.maxConLifeTimer = None self.dbSession = datastore.getDbSession()
def setUp(self): self.factory = WebSocketServerFactory() self.factory.setProtocolOptions( trustXForwardedFor=2 ) self.proto = WebSocketServerProtocol() self.proto.transport = StringTransport() self.proto.factory = self.factory self.proto.failHandshake = Mock() self.proto._connectionMade()
def test_handshake_fails(self): """ A handshake from a client only supporting Hixie-76 will fail. """ t = FakeTransport() f = WebSocketServerFactory() p = WebSocketServerProtocol() p.factory = f p.transport = t # from http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76 http_request = b"GET /demo HTTP/1.1\r\nHost: example.com\r\nConnection: Upgrade\r\nSec-WebSocket-Key2: 12998 5 Y3 1 .P00\r\nSec-WebSocket-Protocol: sample\r\nUpgrade: WebSocket\r\nSec-WebSocket-Key1: 4 @1 46546xW%0l 1 5\r\nOrigin: http://example.com\r\n\r\n^n:ds[4U" p.openHandshakeTimeout = 0 p._connectionMade() p.data = http_request p.processHandshake() self.assertIn(b"HTTP/1.1 400", t._written) self.assertIn(b"Hixie76 protocol not supported", t._written)
def setUp(self): self.factory = WebSocketServerFactory() self.factory.setProtocolOptions( allowedOrigins=[u'127.0.0.1:*', u'*.example.com:*'] ) self.proto = WebSocketServerProtocol() self.proto.transport = StringTransport() self.proto.factory = self.factory self.proto.failHandshake = Mock() self.proto._connectionMade()
def _sendAutoPing(self): """Override for sanity checking during auto-ping interval""" if not self.ps.uaid: # No uaid yet, drop the connection self.ps.metrics.increment("client.autoping.no_uaid", tags=self.base_tags) self.sendClose() elif self.ap_settings.clients.get(self.ps.uaid) != self: # UAID, but we're not in clients anymore for some reason self.ps.metrics.increment("client.autoping.invalid_client", tags=self.base_tags) self.sendClose() return WebSocketServerProtocol._sendAutoPing(self)
def onConnect(self, request): """ Обработчик соединения по WebSocket-протоколу. Нужен для того, чтобы вытащить печеньку 'authToken' :param request: Request :type request: autobahn.websocket.protocol.ConnectionRequest :return: """ log.msg('Achtung! Connection! %s', request.peer) self.process_cookies(request) self.token = self.cookies.get(self.cookie_name) return WebSocketServerProtocol.onConnect(self, request)
def connectionLost(self, reason): """ При аварийном завершении коннекта :param reason: :return: """ #проверяется список приконекченных клиентов, #каждый клиент - одна вкладка if self.factory.clients[self] != '': #если не пуст список #json с новым списком клиентов и инфой, что один отдисконнектился disconnect_msg = json.dumps({'user_disconnect': self.factory.clients[self]}) #возвращаем инфу клиенту о дисконекте self.factory.broadcast(disconnect_msg, self) #удаляем объект, чистим следы self.factory.remove_game(self) self.factory.unregister(self) #посылаем общее сообщение, что коннект завершен с причиной WebSocketServerProtocol.connectionLost(self, reason)
class WebSocketOriginMatching(unittest.TestCase): """ Test that we match Origin: headers properly, when asked to """ def setUp(self): self.factory = WebSocketServerFactory() self.factory.setProtocolOptions( allowedOrigins=[u'127.0.0.1:*', u'*.example.com:*'] ) self.proto = WebSocketServerProtocol() self.proto.transport = StringTransport() self.proto.factory = self.factory self.proto.failHandshake = Mock() self.proto._connectionMade() def tearDown(self): for call in [ self.proto.autoPingPendingCall, self.proto.autoPingTimeoutCall, self.proto.openHandshakeTimeoutCall, self.proto.closeHandshakeTimeoutCall, ]: if call is not None: call.cancel() def test_match_full_origin(self): self.proto.data = b"\r\n".join([ b'GET /ws HTTP/1.1', b'Host: www.example.com', b'Sec-WebSocket-Version: 13', b'Origin: http://www.example.com.malicious.com', b'Sec-WebSocket-Extensions: permessage-deflate', b'Sec-WebSocket-Key: tXAxWFUqnhi86Ajj7dRY5g==', b'Connection: keep-alive, Upgrade', b'Upgrade: websocket', b'\r\n', # last string doesn't get a \r\n from join() ]) self.proto.consumeData() self.assertTrue(self.proto.failHandshake.called, "Handshake should have failed") arg = self.proto.failHandshake.mock_calls[0][1][0] self.assertTrue('not allowed' in arg) def test_match_wrong_scheme_origin(self): # some monkey-business since we already did this in setUp, but # we want a different set of matching origins self.factory.setProtocolOptions( allowedOrigins=[u'http://*.example.com:*'] ) self.proto.allowedOriginsPatterns = self.factory.allowedOriginsPatterns self.proto.allowedOrigins = self.factory.allowedOrigins # the actual test self.factory.isSecure = False self.proto.data = b"\r\n".join([ b'GET /ws HTTP/1.1', b'Host: www.example.com', b'Sec-WebSocket-Version: 13', b'Origin: https://www.example.com', b'Sec-WebSocket-Extensions: permessage-deflate', b'Sec-WebSocket-Key: tXAxWFUqnhi86Ajj7dRY5g==', b'Connection: keep-alive, Upgrade', b'Upgrade: websocket', b'\r\n', # last string doesn't get a \r\n from join() ]) self.proto.consumeData() self.assertTrue(self.proto.failHandshake.called, "Handshake should have failed") arg = self.proto.failHandshake.mock_calls[0][1][0] self.assertTrue('not allowed' in arg) def test_match_origin_secure_scheme(self): self.factory.isSecure = True self.factory.port = 443 self.proto.data = b"\r\n".join([ b'GET /ws HTTP/1.1', b'Host: www.example.com', b'Sec-WebSocket-Version: 13', b'Origin: https://www.example.com', b'Sec-WebSocket-Extensions: permessage-deflate', b'Sec-WebSocket-Key: tXAxWFUqnhi86Ajj7dRY5g==', b'Connection: keep-alive, Upgrade', b'Upgrade: websocket', b'\r\n', # last string doesn't get a \r\n from join() ]) self.proto.consumeData() self.assertFalse(self.proto.failHandshake.called, "Handshake should have succeeded") def test_match_origin_documentation_example(self): """ Test the examples from the docs """ self.factory.setProtocolOptions( allowedOrigins=['*://*.example.com:*'] ) self.factory.isSecure = True self.factory.port = 443 self.proto.data = b"\r\n".join([ b'GET /ws HTTP/1.1', b'Host: www.example.com', b'Sec-WebSocket-Version: 13', b'Origin: http://www.example.com', b'Sec-WebSocket-Extensions: permessage-deflate', b'Sec-WebSocket-Key: tXAxWFUqnhi86Ajj7dRY5g==', b'Connection: keep-alive, Upgrade', b'Upgrade: websocket', b'\r\n', # last string doesn't get a \r\n from join() ]) self.proto.consumeData() self.assertFalse(self.proto.failHandshake.called, "Handshake should have succeeded") def test_match_origin_examples(self): """ All the example origins from RFC6454 (3.2.1) """ # we're just testing the low-level function here... from autobahn.websocket.protocol import _is_same_origin, _url_to_origin policy = wildcards2patterns(['*example.com:*']) # should parametrize test ... for url in ['http://example.com/', 'http://example.com:80/', 'http://example.com/path/file', 'http://example.com/;semi=true', # 'http://example.com./', '//example.com/', 'http://@example.com']: self.assertTrue(_is_same_origin(_url_to_origin(url), 'http', 80, policy), url) def test_match_origin_counter_examples(self): """ All the example 'not-same' origins from RFC6454 (3.2.1) """ # we're just testing the low-level function here... from autobahn.websocket.protocol import _is_same_origin, _url_to_origin policy = wildcards2patterns(['example.com']) for url in ['http://ietf.org/', 'http://example.org/', 'https://example.com/', 'http://example.com:8080/', 'http://www.example.com/']: self.assertFalse(_is_same_origin(_url_to_origin(url), 'http', 80, policy)) def test_match_origin_edge(self): # we're just testing the low-level function here... from autobahn.websocket.protocol import _is_same_origin, _url_to_origin policy = wildcards2patterns(['http://*example.com:80']) self.assertTrue( _is_same_origin(_url_to_origin('http://example.com:80'), 'http', 80, policy) ) self.assertFalse( _is_same_origin(_url_to_origin('http://example.com:81'), 'http', 81, policy) ) self.assertFalse( _is_same_origin(_url_to_origin('https://example.com:80'), 'http', 80, policy) ) def test_origin_from_url(self): from autobahn.websocket.protocol import _url_to_origin # basic function self.assertEqual( _url_to_origin('http://example.com'), ('http', 'example.com', 80) ) # should lower-case scheme self.assertEqual( _url_to_origin('hTTp://example.com'), ('http', 'example.com', 80) ) def test_origin_file(self): from autobahn.websocket.protocol import _url_to_origin self.assertEqual('null', _url_to_origin('file:///etc/passwd')) def test_origin_null(self): from autobahn.websocket.protocol import _is_same_origin, _url_to_origin self.assertEqual('null', _url_to_origin('null')) self.assertFalse( _is_same_origin(_url_to_origin('null'), 'http', 80, []) ) self.assertFalse( _is_same_origin(_url_to_origin('null'), 'https', 80, []) ) self.assertFalse( _is_same_origin(_url_to_origin('null'), '', 80, []) ) self.assertFalse( _is_same_origin(_url_to_origin('null'), None, 80, []) )
def connectionLost(self, reason): WebSocketServerProtocol.connectionLost(self, reason) self.factory.unregister(self)
class ExceptionHandlingTests(unittest.TestCase): """ Tests that we format various exception variations properly during connectionLost """ def setUp(self): self.factory = WebSocketServerFactory() self.proto = WebSocketServerProtocol() self.proto.factory = self.factory self.proto.log = Mock() def tearDown(self): for call in [ self.proto.autoPingPendingCall, self.proto.autoPingTimeoutCall, self.proto.openHandshakeTimeoutCall, self.proto.closeHandshakeTimeoutCall, ]: if call is not None: call.cancel() def test_connection_done(self): # pretend we connected self.proto._connectionMade() self.proto.connectionLost(Failure(ConnectionDone())) messages = ' '.join([str(x[1]) for x in self.proto.log.mock_calls]) self.assertTrue('closed cleanly' in messages) def test_connection_aborted(self): # pretend we connected self.proto._connectionMade() self.proto.connectionLost(Failure(ConnectionAborted())) messages = ' '.join([str(x[1]) for x in self.proto.log.mock_calls]) self.assertTrue(' aborted ' in messages) def test_connection_lost(self): # pretend we connected self.proto._connectionMade() self.proto.connectionLost(Failure(ConnectionLost())) messages = ' '.join([str(x[1]) for x in self.proto.log.mock_calls]) self.assertTrue(' was lost ' in messages) def test_connection_lost_arg(self): # pretend we connected self.proto._connectionMade() self.proto.connectionLost(Failure(ConnectionLost("greetings"))) messages = ' '.join([str(x[1]) + str(x[2]) for x in self.proto.log.mock_calls]) self.assertTrue(' was lost ' in messages) self.assertTrue('greetings' in messages)
def __init__(self, factory): WebSocketServerProtocol.__init__(self) self.factory = factory
def onMessageBegin(self, isBinary): WebSocketServerProtocol.onMessageBegin(self, isBinary) self.sha256 = hashlib.sha256()
def __init__(self, master): WebSocketServerProtocol.__init__(self) self.master = master self.qrefs = {} self.debug = self.master.config.www.get('debug', False)
def connectionLost(self, reason): WebSocketServerProtocol.connectionLost(self, reason) BroadcastServerFactory.unregister(self)
def __init__(self, broker=None): WebSocketServerProtocol.__init__(self) self._discovery_response_defer = None self._protocol_response_defer = None self._open_protocol_response_defer = None
def onMessageFrameBegin(self, length): WebSocketServerProtocol.onMessageFrameBegin(self, length) self.beginMessageFrame(length)
def onMessageBegin(self, isBinary): WebSocketServerProtocol.onMessageBegin(self, isBinary) self.beginMessage(isBinary=isBinary)
def __init__(self): self.settings = spec.supervisor.get_settings_object() WebSocketServerProtocol.__init__(self)
def onMessageBegin(self, isBinary): #print "onMessageBegin" WebSocketServerProtocol.onMessageBegin(self, isBinary) self.beginMessage(isBinary = isBinary)
def connectionLost(self, reason): WebSocketServerProtocol.connectionLost(self, reason) self.factory.unregister(self) bridge.socketIn.close() bridge.socketOut.close()
def setUp(self): self.factory = WebSocketServerFactory() self.proto = WebSocketServerProtocol() self.proto.factory = self.factory self.proto.log = Mock()
def onMessageFrameBegin(self, length): #print "onMessageFrameBegin" WebSocketServerProtocol.onMessageFrameBegin(self, length) self.beginMessageFrame(length)