desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Callback after onConnect() returns successfully. Generates the response for the handshake.'
| def succeedHandshake(self, res):
| protocol = None
headers = {}
if (type(res) == tuple):
if (len(res) > 0):
protocol = res[0]
if (len(res) > 1):
headers = res[1]
else:
protocol = res
if ((protocol is not None) and (not (protocol in self.websocket_protocols))):
raise Exception('p... |
'During opening handshake the client request was invalid, we send a HTTP
error response and then drop the connection.'
| def failHandshake(self, reason, code=400, responseHeaders=None):
| self.wasNotCleanReason = reason
self.log.info("failing WebSocket opening handshake ('{reason}')", reason=reason)
self.sendHttpErrorResponse(code, reason, responseHeaders)
self.dropConnection(abort=False)
|
'Send out HTTP error response.'
| def sendHttpErrorResponse(self, code, reason, responseHeaders=None):
| response = 'HTTP/1.1 {0} {1}\r\n'.format(code, reason)
if responseHeaders:
for h in responseHeaders:
response += '{0}: {1}\r\n'.format(h[0], h[1])
response += '\r\n'
self.sendData(response.encode('utf8'))
|
'Send HTML page HTTP response.'
| def sendHtml(self, html):
| responseBody = html.encode('utf8')
response = 'HTTP/1.1 200 OK\r\n'
if ((self.factory.server is not None) and (self.factory.server != '')):
response += ('Server: %s\r\n' % self.factory.server)
response += 'Content-Type: text/html; charset=UTF-8\r\n'
response += ('Content-Lengt... |
'Send HTTP Redirect (303) response.'
| def sendRedirect(self, url):
| response = 'HTTP/1.1 303\r\n'
if ((self.factory.server is not None) and (self.factory.server != '')):
response += ('Server: %s\r\n' % self.factory.server)
response += ('Location: %s\r\n' % url)
response += '\r\n'
self.sendData(response.encode('utf8'))
|
'Used to send out server status/version upon receiving a HTTP/GET without
upgrade to WebSocket header (and option serverStatus is True).'
| def sendServerStatus(self, redirectUrl=None, redirectAfter=0):
| if redirectUrl:
redirect = ('<meta http-equiv="refresh" content="%d;URL=\'%s\'">' % (redirectAfter, redirectUrl))
else:
redirect = ''
self.sendHtml((_SERVER_STATUS_TEMPLATE % (redirect, __version__)))
|
'Implements :func:`autobahn.websocket.interfaces.IWebSocketServerChannelFactory.__init__`'
| def __init__(self, url=None, protocols=None, server=('AutobahnPython/%s' % __version__), headers=None, externalPort=None):
| self.logOctets = False
self.logFrames = False
self.trackTimings = False
self._batched_timer = txaio.make_batched_timer(bucket_seconds=0.2, chunk_size=1000)
random.seed()
self.setSessionParameters(url, protocols, server, headers, externalPort)
self.resetProtocolOptions()
self.countConnect... |
'Implements :func:`autobahn.websocket.interfaces.IWebSocketServerChannelFactory.setSessionParameters`'
| def setSessionParameters(self, url=None, protocols=None, server=None, headers=None, externalPort=None):
| (isSecure, host, port, resource, path, params) = parse_url((url or 'ws://localhost'))
if (len(params) > 0):
raise Exception('query parameters specified for server WebSocket URL')
self.url = url
self.isSecure = isSecure
self.host = host
self.port = port
self.resource... |
'Implements :func:`autobahn.websocket.interfaces.IWebSocketServerChannelFactory.resetProtocolOptions`'
| def resetProtocolOptions(self):
| self.versions = WebSocketProtocol.SUPPORTED_PROTOCOL_VERSIONS
self.webStatus = True
self.utf8validateIncoming = True
self.requireMaskedClientFrames = True
self.maskServerFrames = False
self.applyMask = True
self.maxFramePayloadSize = 0
self.maxMessagePayloadSize = 0
self.autoFragment... |
'Implements :func:`autobahn.websocket.interfaces.IWebSocketServerChannelFactory.setProtocolOptions`'
| def setProtocolOptions(self, versions=None, webStatus=None, utf8validateIncoming=None, maskServerFrames=None, requireMaskedClientFrames=None, applyMask=None, maxFramePayloadSize=None, maxMessagePayloadSize=None, autoFragmentSize=None, failByDrop=None, echoCloseCodeReason=None, openHandshakeTimeout=None, closeHandshakeT... | if (versions is not None):
for v in versions:
if (v not in WebSocketProtocol.SUPPORTED_PROTOCOL_VERSIONS):
raise Exception(('invalid WebSocket protocol version %s (allowed values: %s)' % (v, str(WebSocketProtocol.SUPPORTED_PROTOCOL_VERSIONS))))
if (se... |
'Get number of currently connected clients.
:returns: int -- Number of currently connected clients.'
| def getConnectionCount(self):
| return self.countConnections
|
'Callback fired directly after WebSocket opening handshake when new WebSocket server
connection was established.
:param response: WebSocket connection response information.
:type response: instance of :class:`autobahn.websocket.protocol.ConnectionResponse`'
| def onConnect(self, response):
| pass
|
'Called by network framework when new transport connection to server was established. Default
implementation will start the initial WebSocket opening handshake (or proxy connect).
When overriding in derived class, make sure to call this base class
implementation _before_ your code.'
| def _connectionMade(self):
| WebSocketProtocol._connectionMade(self)
self.log.debug('connection to {peer} established', peer=self.peer)
if ((not self.factory.isServer) and (self.factory.proxy is not None)):
self.startProxyConnect()
else:
self.startHandshake()
|
'Called by network framework when established transport connection to server was lost. Default
implementation will tear down all state properly.
When overriding in derived class, make sure to call this base class
implementation _after_ your code.'
| def _connectionLost(self, reason):
| WebSocketProtocol._connectionLost(self, reason)
|
'Connect to explicit proxy.'
| def startProxyConnect(self):
| request = ('CONNECT %s:%d HTTP/1.1\r\n' % (self.factory.host.encode('utf-8'), self.factory.port))
request += ('Host: %s:%d\r\n' % (self.factory.host.encode('utf-8'), self.factory.port))
request += '\r\n'
self.log.debug('{request}', request=request)
self.sendData(request)
|
'Process HTTP/CONNECT response from server.'
| def processProxyConnect(self):
| end_of_header = self.data.find('\r\n\r\n')
if (end_of_header >= 0):
http_response_data = self.data[:(end_of_header + 4)]
self.log.debug('received HTTP response:\n\n{response}\n\n', response=http_response_data)
(http_status_line, http_headers, http_headers_cnt) = parseHttpHeader(htt... |
'During initial explicit proxy connect, the server response indicates some failure and we drop the
connection.'
| def failProxyConnect(self, reason):
| self.log.debug("failing proxy connect ('{reason}')", reason=reason)
self.dropConnection(abort=True)
|
'Start WebSocket opening handshake.'
| def startHandshake(self):
| request = ('GET %s HTTP/1.1\r\n' % self.factory.resource)
if ((self.factory.useragent is not None) and (self.factory.useragent != '')):
request += ('User-Agent: %s\r\n' % self.factory.useragent)
request += ('Host: %s:%d\r\n' % (self.factory.host, self.factory.port))
request += 'Upgra... |
'Process WebSocket opening handshake response from server.'
| def processHandshake(self):
| end_of_header = self.data.find('\r\n\r\n')
if (end_of_header >= 0):
self.http_response_data = self.data[:(end_of_header + 4)]
self.log.debug('received HTTP response:\n\n{response}\n\n', response=self.http_response_data)
(self.http_status_line, self.http_headers, http_headers_cnt) =... |
'During opening handshake the server response is invalid and we drop the
connection.'
| def failHandshake(self, reason):
| self.wasNotCleanReason = reason
self.log.info("failing WebSocket opening handshake ('{reason}')", reason=reason)
self.dropConnection(abort=True)
|
'Implements :func:`autobahn.websocket.interfaces.IWebSocketClientChannelFactory.__init__`'
| def __init__(self, url=None, origin=None, protocols=None, useragent=('AutobahnPython/%s' % __version__), headers=None, proxy=None):
| self.logOctets = False
self.logFrames = False
self.trackTimings = False
self._batched_timer = txaio.make_batched_timer(bucket_seconds=0.2, chunk_size=1000)
random.seed()
self.setSessionParameters(url, origin, protocols, useragent, headers, proxy)
self.resetProtocolOptions()
|
'Implements :func:`autobahn.websocket.interfaces.IWebSocketClientChannelFactory.setSessionParameters`'
| def setSessionParameters(self, url=None, origin=None, protocols=None, useragent=None, headers=None, proxy=None):
| (isSecure, host, port, resource, path, params) = parse_url((url or 'ws://localhost'))
self.url = url
self.isSecure = isSecure
self.host = host
self.port = port
self.resource = resource
self.path = path
self.params = params
self.origin = origin
self.protocols = (protocols or [])
... |
'Implements :func:`autobahn.websocket.interfaces.IWebSocketClientChannelFactory.resetProtocolOptions`'
| def resetProtocolOptions(self):
| self.version = WebSocketProtocol.DEFAULT_SPEC_VERSION
self.utf8validateIncoming = True
self.acceptMaskedServerFrames = False
self.maskClientFrames = True
self.applyMask = True
self.maxFramePayloadSize = 0
self.maxMessagePayloadSize = 0
self.autoFragmentSize = 0
self.failByDrop = True... |
'Implements :func:`autobahn.websocket.interfaces.IWebSocketClientChannelFactory.setProtocolOptions`'
| def setProtocolOptions(self, version=None, utf8validateIncoming=None, acceptMaskedServerFrames=None, maskClientFrames=None, applyMask=None, maxFramePayloadSize=None, maxMessagePayloadSize=None, autoFragmentSize=None, failByDrop=None, echoCloseCodeReason=None, serverConnectionDropTimeout=None, openHandshakeTimeout=None,... | if (version is not None):
if (version not in WebSocketProtocol.SUPPORTED_SPEC_VERSIONS):
raise Exception(('invalid WebSocket draft version %s (allowed values: %s)' % (version, str(WebSocketProtocol.SUPPORTED_SPEC_VERSIONS))))
if (version != self.version):
... |
'Parses a WebSocket extension offer for `permessage-deflate` provided by a client to a server.
:param params: Output from :func:`autobahn.websocket.WebSocketProtocol._parseExtensionsHeader`.
:type params: list
:returns: A new instance of :class:`autobahn.compress.PerMessageDeflateOffer`.
:rtype: obj'
| @classmethod
def parse(cls, params):
| accept_max_window_bits = False
accept_no_context_takeover = True
request_max_window_bits = 0
request_no_context_takeover = False
for p in params:
if (len(params[p]) > 1):
raise Exception(("multiple occurrence of extension parameter '%s' for extension '%s'"... |
':param accept_no_context_takeover: When ``True``, the client accepts the "no context takeover" feature.
:type accept_no_context_takeover: bool
:param accept_max_window_bits: When ``True``, the client accepts setting "max window size".
:type accept_max_window_bits: bool
:param request_no_context_takeover: When ``True``... | def __init__(self, accept_no_context_takeover=True, accept_max_window_bits=True, request_no_context_takeover=False, request_max_window_bits=0):
| if (type(accept_no_context_takeover) != bool):
raise Exception(('invalid type %s for accept_no_context_takeover' % type(accept_no_context_takeover)))
self.accept_no_context_takeover = accept_no_context_takeover
if (type(accept_max_window_bits) != bool):
raise Exception(('invalid ... |
'Returns the WebSocket extension configuration string as sent to the server.
:returns: PMCE configuration string.
:rtype: str'
| def get_extension_string(self):
| pmce_string = self.EXTENSION_NAME
if self.accept_no_context_takeover:
pmce_string += '; client_no_context_takeover'
if self.accept_max_window_bits:
pmce_string += '; client_max_window_bits'
if self.request_no_context_takeover:
pmce_string += '; server_no_context_takeover... |
'Returns a JSON serializable object representation.
:returns: JSON serializable representation.
:rtype: dict'
| def __json__(self):
| return {'extension': self.EXTENSION_NAME, 'accept_no_context_takeover': self.accept_no_context_takeover, 'accept_max_window_bits': self.accept_max_window_bits, 'request_no_context_takeover': self.request_no_context_takeover, 'request_max_window_bits': self.request_max_window_bits}
|
'Returns Python object representation that can be eval\'ed to reconstruct the object.
:returns: Python string representation.
:rtype: str'
| def __repr__(self):
| return ('PerMessageDeflateOffer(accept_no_context_takeover = %s, accept_max_window_bits = %s, request_no_context_takeover = %s, request_max_window_bits = %s)' % (self.accept_no_context_takeover, self.accept_max_window_bits, self.request_no_context_takeover, self.request_max_window_b... |
':param offer: The offer being accepted.
:type offer: Instance of :class:`autobahn.compress.PerMessageDeflateOffer`.
:param request_no_context_takeover: When ``True``, the server requests the "no context takeover" feature.
:type request_no_context_takeover: bool
:param request_max_window_bits: When non-zero, the server... | def __init__(self, offer, request_no_context_takeover=False, request_max_window_bits=0, no_context_takeover=None, window_bits=None, mem_level=None):
| if (not isinstance(offer, PerMessageDeflateOffer)):
raise Exception(('invalid type %s for offer' % type(offer)))
self.offer = offer
if (type(request_no_context_takeover) != bool):
raise Exception(('invalid type %s for request_no_context_takeover' % type(request_no_con... |
'Returns the WebSocket extension configuration string as sent to the server.
:returns: PMCE configuration string.
:rtype: str'
| def get_extension_string(self):
| pmce_string = self.EXTENSION_NAME
if self.offer.request_no_context_takeover:
pmce_string += '; server_no_context_takeover'
if (self.offer.request_max_window_bits != 0):
pmce_string += ('; server_max_window_bits=%d' % self.offer.request_max_window_bits)
if self.request_no_context_ta... |
'Returns a JSON serializable object representation.
:returns: JSON serializable representation.
:rtype: dict'
| def __json__(self):
| return {'extension': self.EXTENSION_NAME, 'offer': self.offer.__json__(), 'request_no_context_takeover': self.request_no_context_takeover, 'request_max_window_bits': self.request_max_window_bits, 'no_context_takeover': self.no_context_takeover, 'window_bits': self.window_bits, 'mem_level': self.mem_level}
|
'Returns Python object representation that can be eval\'ed to reconstruct the object.
:returns: Python string representation.
:rtype: str'
| def __repr__(self):
| return ('PerMessageDeflateOfferAccept(offer = %s, request_no_context_takeover = %s, request_max_window_bits = %s, no_context_takeover = %s, window_bits = %s, mem_level = %s)' % (self.offer.__repr__(), self.request_no_context_takeover, self.request_max_window_bits, ... |
'Parses a WebSocket extension response for `permessage-deflate` provided by a server to a client.
:param params: Output from :func:`autobahn.websocket.WebSocketProtocol._parseExtensionsHeader`.
:type params: list
:returns: A new instance of :class:`autobahn.compress.PerMessageDeflateResponse`.
:rtype: obj'
| @classmethod
def parse(cls, params):
| client_max_window_bits = 0
client_no_context_takeover = False
server_max_window_bits = 0
server_no_context_takeover = False
for p in params:
if (len(params[p]) > 1):
raise Exception(("multiple occurrence of extension parameter '%s' for extension '%s'" % (p... |
':param client_max_window_bits: FIXME
:type client_max_window_bits: int
:param client_no_context_takeover: FIXME
:type client_no_context_takeover: bool
:param server_max_window_bits: FIXME
:type server_max_window_bits: int
:param server_no_context_takeover: FIXME
:type server_no_context_takeover: bool'
| def __init__(self, client_max_window_bits, client_no_context_takeover, server_max_window_bits, server_no_context_takeover):
| self.client_max_window_bits = client_max_window_bits
self.client_no_context_takeover = client_no_context_takeover
self.server_max_window_bits = server_max_window_bits
self.server_no_context_takeover = server_no_context_takeover
|
'Returns a JSON serializable object representation.
:returns: JSON serializable representation.
:rtype: dict'
| def __json__(self):
| return {'extension': self.EXTENSION_NAME, 'client_max_window_bits': self.client_max_window_bits, 'client_no_context_takeover': self.client_no_context_takeover, 'server_max_window_bits': self.server_max_window_bits, 'server_no_context_takeover': self.server_no_context_takeover}
|
'Returns Python object representation that can be eval\'ed to reconstruct the object.
:returns: Python string representation.
:rtype: str'
| def __repr__(self):
| return ('PerMessageDeflateResponse(client_max_window_bits = %s, client_no_context_takeover = %s, server_max_window_bits = %s, server_no_context_takeover = %s)' % (self.client_max_window_bits, self.client_no_context_takeover, self.server_max_window_bits, self.server_no_context_takeov... |
':param response: The response being accepted.
:type response: Instance of :class:`autobahn.compress.PerMessageDeflateResponse`.
:param no_context_takeover: Override client ("client-to-server direction") context takeover (this must be compatible with response).
:type no_context_takeover: bool
:param window_bits: Overri... | def __init__(self, response, no_context_takeover=None, window_bits=None, mem_level=None):
| if (not isinstance(response, PerMessageDeflateResponse)):
raise Exception(('invalid type %s for response' % type(response)))
self.response = response
if (no_context_takeover is not None):
if (type(no_context_takeover) != bool):
raise Exception(('invalid type %s ... |
'Returns a JSON serializable object representation.
:returns: JSON serializable representation.
:rtype: dict'
| def __json__(self):
| return {'extension': self.EXTENSION_NAME, 'response': self.response.__json__(), 'no_context_takeover': self.no_context_takeover, 'window_bits': self.window_bits, 'mem_level': self.mem_level}
|
'Returns Python object representation that can be eval\'ed to reconstruct the object.
:returns: Python string representation.
:rtype: str'
| def __repr__(self):
| return ('PerMessageDeflateResponseAccept(response = %s, no_context_takeover = %s, window_bits = %s, mem_level = %s)' % (self.response.__repr__(), self.no_context_takeover, self.window_bits, self.mem_level))
|
'Parses a WebSocket extension offer for `permessage-snappy` provided by a client to a server.
:param params: Output from :func:`autobahn.websocket.WebSocketProtocol._parseExtensionsHeader`.
:type params: list
:returns: A new instance of :class:`autobahn.compress.PerMessageSnappyOffer`.
:rtype: obj'
| @classmethod
def parse(cls, params):
| accept_no_context_takeover = False
request_no_context_takeover = False
for p in params:
if (len(params[p]) > 1):
raise Exception(("multiple occurrence of extension parameter '%s' for extension '%s'" % (p, cls.EXTENSION_NAME)))
val = params[p][0]
if... |
':param accept_no_context_takeover: Iff true, client accepts "no context takeover" feature.
:type accept_no_context_takeover: bool
:param request_no_context_takeover: Iff true, client request "no context takeover" feature.
:type request_no_context_takeover: bool'
| def __init__(self, accept_no_context_takeover=True, request_no_context_takeover=False):
| if (type(accept_no_context_takeover) != bool):
raise Exception(('invalid type %s for accept_no_context_takeover' % type(accept_no_context_takeover)))
self.accept_no_context_takeover = accept_no_context_takeover
if (type(request_no_context_takeover) != bool):
raise Exception(('inv... |
'Returns the WebSocket extension configuration string as sent to the server.
:returns: PMCE configuration string.
:rtype: str'
| def get_extension_string(self):
| pmce_string = self.EXTENSION_NAME
if self.accept_no_context_takeover:
pmce_string += '; client_no_context_takeover'
if self.request_no_context_takeover:
pmce_string += '; server_no_context_takeover'
return pmce_string
|
'Returns a JSON serializable object representation.
:returns: JSON serializable representation.
:rtype: dict'
| def __json__(self):
| return {'extension': self.EXTENSION_NAME, 'accept_no_context_takeover': self.accept_no_context_takeover, 'request_no_context_takeover': self.request_no_context_takeover}
|
'Returns Python object representation that can be eval\'ed to reconstruct the object.
:returns: Python string representation.
:rtype: str'
| def __repr__(self):
| return ('PerMessageSnappyOffer(accept_no_context_takeover = %s, request_no_context_takeover = %s)' % (self.accept_no_context_takeover, self.request_no_context_takeover))
|
':param offer: The offer being accepted.
:type offer: Instance of :class:`autobahn.compress.PerMessageSnappyOffer`.
:param request_no_context_takeover: Iff true, server request "no context takeover" feature.
:type request_no_context_takeover: bool
:param no_context_takeover: Override server ("server-to-client direction... | def __init__(self, offer, request_no_context_takeover=False, no_context_takeover=None):
| if (not isinstance(offer, PerMessageSnappyOffer)):
raise Exception(('invalid type %s for offer' % type(offer)))
self.offer = offer
if (type(request_no_context_takeover) != bool):
raise Exception(('invalid type %s for request_no_context_takeover' % type(request_no_cont... |
'Returns the WebSocket extension configuration string as sent to the server.
:returns: PMCE configuration string.
:rtype: str'
| def get_extension_string(self):
| pmce_string = self.EXTENSION_NAME
if self.offer.request_no_context_takeover:
pmce_string += '; server_no_context_takeover'
if self.request_no_context_takeover:
pmce_string += '; client_no_context_takeover'
return pmce_string
|
'Returns a JSON serializable object representation.
:returns: JSON serializable representation.
:rtype: dict'
| def __json__(self):
| return {'extension': self.EXTENSION_NAME, 'offer': self.offer.__json__(), 'request_no_context_takeover': self.request_no_context_takeover, 'no_context_takeover': self.no_context_takeover}
|
'Returns Python object representation that can be eval\'ed to reconstruct the object.
:returns: Python string representation.
:rtype: str'
| def __repr__(self):
| return ('PerMessageSnappyAccept(offer = %s, request_no_context_takeover = %s, no_context_takeover = %s)' % (self.offer.__repr__(), self.request_no_context_takeover, self.no_context_takeover))
|
'Parses a WebSocket extension response for `permessage-snappy` provided by a server to a client.
:param params: Output from :func:`autobahn.websocket.WebSocketProtocol._parseExtensionsHeader`.
:type params: list
:returns: A new instance of :class:`autobahn.compress.PerMessageSnappyResponse`.
:rtype: obj'
| @classmethod
def parse(cls, params):
| client_no_context_takeover = False
server_no_context_takeover = False
for p in params:
if (len(params[p]) > 1):
raise Exception(("multiple occurrence of extension parameter '%s' for extension '%s'" % (p, cls.EXTENSION_NAME)))
val = params[p][0]
if ... |
'Returns a JSON serializable object representation.
:returns: JSON serializable representation.
:rtype: dict'
| def __json__(self):
| return {'extension': self.EXTENSION_NAME, 'client_no_context_takeover': self.client_no_context_takeover, 'server_no_context_takeover': self.server_no_context_takeover}
|
'Returns Python object representation that can be eval\'ed to reconstruct the object.
:returns: Python string representation.
:rtype: str'
| def __repr__(self):
| return ('PerMessageSnappyResponse(client_no_context_takeover = %s, server_no_context_takeover = %s)' % (self.client_no_context_takeover, self.server_no_context_takeover))
|
':param response: The response being accepted.
:type response: Instance of :class:`autobahn.compress.PerMessageSnappyResponse`.
:param no_context_takeover: Override client ("client-to-server direction") context takeover (this must be compatible with response).
:type no_context_takeover: bool'
| def __init__(self, response, no_context_takeover=None):
| if (not isinstance(response, PerMessageSnappyResponse)):
raise Exception(('invalid type %s for response' % type(response)))
self.response = response
if (no_context_takeover is not None):
if (type(no_context_takeover) != bool):
raise Exception(('invalid type %s ... |
'Returns a JSON serializable object representation.
:returns: JSON serializable representation.
:rtype: dict'
| def __json__(self):
| return {'extension': self.EXTENSION_NAME, 'response': self.response.__json__(), 'no_context_takeover': self.no_context_takeover}
|
'Returns Python object representation that can be eval\'ed to reconstruct the object.
:returns: Python string representation.
:rtype: str'
| def __repr__(self):
| return ('PerMessageSnappyResponseAccept(response = %s, no_context_takeover = %s)' % (self.response.__repr__(), self.no_context_takeover))
|
'sendClose with no code or reason works.'
| def test_sendClose_none(self):
| self.protocol.sendClose()
self.assertEqual(self.transport._written, '\x88\x00')
self.assertEqual(self.protocol.state, self.protocol.STATE_CLOSING)
|
'sendClose with a str reason works.'
| def test_sendClose_str_reason(self):
| self.protocol.sendClose(code=1000, reason=u'oh no')
self.assertEqual(self.transport._written[2:], '\x03\xe8oh no')
self.assertEqual(self.protocol.state, self.protocol.STATE_CLOSING)
|
'sendClose with a unicode reason works.'
| def test_sendClose_unicode_reason(self):
| self.protocol.sendClose(code=1000, reason=u'oh no')
self.assertEqual(self.transport._written[2:], '\x03\xe8oh no')
self.assertEqual(self.protocol.state, self.protocol.STATE_CLOSING)
|
'sendClose with a too-long reason will truncate it.'
| def test_sendClose_toolong(self):
| self.protocol.sendClose(code=1000, reason=(u'abc' * 1000))
self.assertEqual(self.transport._written[2:], ('\x03\xe8' + ('abc' * 41)))
self.assertEqual(self.protocol.state, self.protocol.STATE_CLOSING)
|
'Trying to sendClose with a reason but no code will raise an Exception.'
| def test_sendClose_reason_with_no_code(self):
| with self.assertRaises(Exception) as e:
self.protocol.sendClose(reason=u'abc')
self.assertIn('close reason without close code', str(e.exception))
self.assertEqual(self.transport._written, '')
self.assertEqual(self.protocol.state, self.protocol.STATE_OPEN)
|
'Trying to sendClose with a non-int code will raise an Exception.'
| def test_sendClose_invalid_code_type(self):
| with self.assertRaises(Exception) as e:
self.protocol.sendClose(code='134')
self.assertIn('invalid type', str(e.exception))
self.assertEqual(self.transport._written, '')
self.assertEqual(self.protocol.state, self.protocol.STATE_OPEN)
|
'Trying to sendClose with a non-valid int code will raise an Exception.'
| def test_sendClose_invalid_code_value(self):
| with self.assertRaises(Exception) as e:
self.protocol.sendClose(code=10)
self.assertIn('invalid close code 10', str(e.exception))
self.assertEqual(self.transport._written, '')
self.assertEqual(self.protocol.state, self.protocol.STATE_OPEN)
|
'Parses a WebSocket extension offer for `permessage-bzip2` provided by a client to a server.
:param params: Output from :func:`autobahn.websocket.WebSocketProtocol._parseExtensionsHeader`.
:type params: list
:returns: object -- A new instance of :class:`autobahn.compress.PerMessageBzip2Offer`.'
| @classmethod
def parse(cls, params):
| accept_max_compress_level = False
request_max_compress_level = 0
for p in params:
if (len(params[p]) > 1):
raise Exception(("multiple occurrence of extension parameter '%s' for extension '%s'" % (p, cls.EXTENSION_NAME)))
val = params[p][0]
if (p ==... |
'Constructor.
:param accept_max_compress_level: Iff true, client accepts "maximum compression level" parameter.
:type accept_max_compress_level: bool
:param request_max_compress_level: Iff non-zero, client requests given "maximum compression level" - must be 1-9.
:type request_max_compress_level: int'
| def __init__(self, accept_max_compress_level=True, request_max_compress_level=0):
| if (type(accept_max_compress_level) != bool):
raise Exception(('invalid type %s for accept_max_compress_level' % type(accept_max_compress_level)))
self.accept_max_compress_level = accept_max_compress_level
if ((request_max_compress_level != 0) and (request_max_compress_level not in self.... |
'Returns the WebSocket extension configuration string as sent to the server.
:returns: PMCE configuration string.
:rtype: str'
| def get_extension_string(self):
| pmce_string = self.EXTENSION_NAME
if self.accept_max_compress_level:
pmce_string += '; client_max_compress_level'
if (self.request_max_compress_level != 0):
pmce_string += ('; server_max_compress_level=%d' % self.request_max_compress_level)
return pmce_string
|
'Returns a JSON serializable object representation.
:returns: JSON serializable representation.
:rtype: dict'
| def __json__(self):
| return {'extension': self.EXTENSION_NAME, 'accept_max_compress_level': self.accept_max_compress_level, 'request_max_compress_level': self.request_max_compress_level}
|
'Returns Python object representation that can be eval\'ed to reconstruct the object.
:returns: Python string representation.
:rtype: str'
| def __repr__(self):
| return ('PerMessageBzip2Offer(accept_max_compress_level = %s, request_max_compress_level = %s)' % (self.accept_max_compress_level, self.request_max_compress_level))
|
'Constructor.
:param offer: The offer being accepted.
:type offer: Instance of :class:`autobahn.compress.PerMessageBzip2Offer`.
:param request_max_compress_level: Iff non-zero, server requests given "maximum compression level" - must be 1-9.
:type request_max_compress_level: int
:param compress_level: Override server (... | def __init__(self, offer, request_max_compress_level=0, compress_level=None):
| if (not isinstance(offer, PerMessageBzip2Offer)):
raise Exception(('invalid type %s for offer' % type(offer)))
self.offer = offer
if ((request_max_compress_level != 0) and (request_max_compress_level not in self.COMPRESS_LEVEL_PERMISSIBLE_VALUES)):
raise Exception(('invalid va... |
'Returns the WebSocket extension configuration string as sent to the server.
:returns: PMCE configuration string.
:rtype: str'
| def get_extension_string(self):
| pmce_string = self.EXTENSION_NAME
if (self.offer.request_max_compress_level != 0):
pmce_string += ('; server_max_compress_level=%d' % self.offer.request_max_compress_level)
if (self.request_max_compress_level != 0):
pmce_string += ('; client_max_compress_level=%d' % self.request_max_co... |
'Returns a JSON serializable object representation.
:returns: JSON serializable representation.
:rtype: dict'
| def __json__(self):
| return {'extension': self.EXTENSION_NAME, 'offer': self.offer.__json__(), 'request_max_compress_level': self.request_max_compress_level, 'compress_level': self.compress_level}
|
'Returns Python object representation that can be eval\'ed to reconstruct the object.
:returns: Python string representation.
:rtype: str'
| def __repr__(self):
| return ('PerMessageBzip2Accept(offer = %s, request_max_compress_level = %s, compress_level = %s)' % (self.offer.__repr__(), self.request_max_compress_level, self.compress_level))
|
'Parses a WebSocket extension response for `permessage-bzip2` provided by a server to a client.
:param params: Output from :func:`autobahn.websocket.WebSocketProtocol._parseExtensionsHeader`.
:type params: list
:returns: A new instance of :class:`autobahn.compress.PerMessageBzip2Response`.
:rtype: obj'
| @classmethod
def parse(cls, params):
| client_max_compress_level = 0
server_max_compress_level = 0
for p in params:
if (len(params[p]) > 1):
raise Exception(("multiple occurrence of extension parameter '%s' for extension '%s'" % (p, cls.EXTENSION_NAME)))
val = params[p][0]
if (p == 'cli... |
'Returns a JSON serializable object representation.
:returns: JSON serializable representation.
:rtype: dict'
| def __json__(self):
| return {'extension': self.EXTENSION_NAME, 'client_max_compress_level': self.client_max_compress_level, 'server_max_compress_level': self.server_max_compress_level}
|
'Returns Python object representation that can be eval\'ed to reconstruct the object.
:returns: Python string representation.
:rtype: str'
| def __repr__(self):
| return ('PerMessageBzip2Response(client_max_compress_level = %s, server_max_compress_level = %s)' % (self.client_max_compress_level, self.server_max_compress_level))
|
':param response: The response being accepted.
:type response: Instance of :class:`autobahn.compress.PerMessageBzip2Response`.
:param compress_level: Override client ("client-to-server direction") compress level (this must be compatible with response).
:type compress_level: int'
| def __init__(self, response, compress_level=None):
| if (not isinstance(response, PerMessageBzip2Response)):
raise Exception(('invalid type %s for response' % type(response)))
self.response = response
if (compress_level is not None):
if (compress_level not in self.COMPRESS_LEVEL_PERMISSIBLE_VALUES):
raise Exception(('in... |
'Returns a JSON serializable object representation.
:returns: JSON serializable representation.
:rtype: dict'
| def __json__(self):
| return {'extension': self.EXTENSION_NAME, 'response': self.response.__json__(), 'compress_level': self.compress_level}
|
'Returns Python object representation that can be eval\'ed to reconstruct the object.
:returns: Python string representation.
:rtype: str'
| def __repr__(self):
| return ('PerMessageBzip2ResponseAccept(response = %s, compress_level = %s)' % (self.response.__repr__(), self.compress_level))
|
':param peer: Descriptor of the connecting client (e.g. IP address/port
in case of TCP transports).
:type peer: str
:param headers: HTTP headers from opening handshake request.
:type headers: dict
:param host: Host from opening handshake HTTP header.
:type host: str
:param path: Path from requested HTTP resource URI. F... | def __init__(self, peer, headers, host, path, params, version, origin, protocols, extensions):
| self.peer = peer
self.headers = headers
self.host = host
self.path = path
self.params = params
self.version = version
self.origin = origin
self.protocols = protocols
self.extensions = extensions
|
'Constructor.
:param peer: Descriptor of the connected server (e.g. IP address/port in case of TCP transport).
:type peer: str
:param headers: HTTP headers from opening handshake response.
:type headers: dict
:param version: The WebSocket protocol version that is spoken.
:type version: int
:param protocol: The WebSocke... | def __init__(self, peer, headers, version, protocol, extensions):
| self.peer = peer
self.headers = headers
self.version = version
self.protocol = protocol
self.extensions = extensions
|
':param subprotocol: The WebSocket connection is accepted with the
this WebSocket subprotocol chosen. The value must be a token
as defined by RFC 2616.
:type subprotocol: unicode or None
:param headers: Additional HTTP headers to send on the WebSocket
opening handshake reply, e.g. cookies. The keys must be unicode,
and... | def __init__(self, subprotocol=None, headers=None):
| assert ((subprotocol is None) or (type(subprotocol) == six.text_type))
assert ((headers is None) or (type(headers) == dict))
if (headers is not None):
for (k, v) in headers.items():
assert (type(k) == six.text_type)
assert ((type(v) == six.text_type) or (type(v) == list) or (... |
':param code: HTTP error code.
:type code: int
:param reason: HTTP error reason.
:type reason: unicode'
| def __init__(self, code, reason=None):
| assert (type(code) == int)
assert ((reason is None) or (type(reason) == six.text_type))
self.code = code
self.reason = reason
|
':param payload: The WebSocket message payload, which can be UTF-8
encoded text or a binary string.
:type payload: bytes
:param is_binary: ``True`` for binary payload, else the payload
contains UTF-8 encoded text.
:type is_binary: bool'
| def __init__(self, payload, is_binary=False):
| assert (type(payload) == bytes)
assert (type(is_binary) == bool)
self.payload = payload
self.is_binary = is_binary
|
':param payload: The WebSocket message payload, which can be UTF-8
encoded text or a binary string.
:type payload: bytes
:param is_binary: ``True`` iff payload is binary, else the payload
contains UTF-8 encoded text.
:type is_binary: bool
:param skip_compress: If ``True``, never compress this message.
This only has an ... | def __init__(self, payload, is_binary=False, skip_compress=False):
| assert (type(payload) == bytes)
assert (type(is_binary) == bool)
assert (type(skip_compress) == bool)
self.payload = payload
self.is_binary = is_binary
self.skip_compress = skip_compress
|
':param payload: The WebSocket ping message payload.
:type payload: bytes or None'
| def __init__(self, payload=None):
| assert ((payload is None) or (type(payload) == bytes)), 'invalid type {} for WebSocket ping payload - must be None or bytes'.format(type(payload))
if (payload is not None):
assert (len(payload) < 126), 'WebSocket ping payload too long ({} bytes) -... |
'Create and connect a WAMP-over-XXX transport.'
| def _connect_transport(self, reactor, transport, session_factory):
| transport_factory = _create_transport_factory(reactor, transport, session_factory)
transport_endpoint = _create_transport_endpoint(reactor, transport.endpoint)
return transport_endpoint.connect(transport_factory)
|
'This starts the Component, which means it will start connecting
(and re-connecting) to its configured transports. A Component
runs until it is "done", which means one of:
- There was a "main" function defined, and it completed successfully;
- Something called ``.leave()`` on our session, and we left successfully;
- ``... | @inlineCallbacks
def start(self, reactor=None):
| if (reactor is None):
self.log.warn('Using default reactor')
from twisted.internet import reactor
(yield self.fire('start', reactor, self))
transport_gen = itertools.cycle(self._transports)
reconnect = True
self.log.debug('Entering re-connect loop')
while reconnect:
... |
'Implements :func:`autobahn.wamp.interfaces.ITransport.send`'
| def send(self, msg):
| if self.isOpen():
self.log.trace('WampRawSocketProtocol: TX WAMP message: {msg}', msg=msg)
try:
(payload, _) = self._serializer.serialize(msg)
except Exception as e:
raise SerializationError('WampRawSocketProtocol: unable to serialize WAMP a... |
'Implements :func:`autobahn.wamp.interfaces.ITransport.isOpen`'
| def isOpen(self):
| return (self._session is not None)
|
'Implements :func:`autobahn.wamp.interfaces.ITransport.close`'
| def close(self):
| if self.isOpen():
self.transport.loseConnection()
else:
raise TransportLost()
|
'Implements :func:`autobahn.wamp.interfaces.ITransport.abort`'
| def abort(self):
| if self.isOpen():
if hasattr(self.transport, 'abortConnection'):
self.transport.abortConnection()
else:
self.transport.loseConnection()
else:
raise TransportLost()
|
'Implements :func:`autobahn.wamp.interfaces.ITransport.get_channel_id`'
| def get_channel_id(self, channel_id_type=u'tls-unique'):
| return transport_channel_id(self.transport, is_server=True, channel_id_type=channel_id_type)
|
'Implements :func:`autobahn.wamp.interfaces.ITransport.get_channel_id`'
| def get_channel_id(self, channel_id_type=u'tls-unique'):
| return transport_channel_id(self.transport, is_server=False, channel_id_type=channel_id_type)
|
':param factory: A callable that produces instances that implement
:class:`autobahn.wamp.interfaces.ITransportHandler`
:type factory: callable
:param serializers: A list of WAMP serializers to use (or ``None``
for all available serializers).
:type serializers: list of objects implementing
:class:`autobahn.wamp.interfac... | def __init__(self, factory, serializers=None):
| if callable(factory):
self._factory = factory
else:
self._factory = (lambda : factory)
if (serializers is None):
serializers = []
try:
from autobahn.wamp.serializer import CBORSerializer
serializers.append(CBORSerializer(batched=True))
seri... |
':param factory: A callable that produces instances that implement
:class:`autobahn.wamp.interfaces.ITransportHandler`
:type factory: callable
:param serializer: The WAMP serializer to use (or ``None`` for
"best" serializer, chosen as the first serializer available from
this list: CBOR, MessagePack, UBJSON, JSON).
:typ... | def __init__(self, factory, serializer=None):
| if callable(factory):
self._factory = factory
else:
self._factory = (lambda : factory)
if (serializer is None):
try:
from autobahn.wamp.serializer import CBORSerializer
serializer = CBORSerializer()
except ImportError:
pass
if (serializ... |
'Register a Twisted producer with this protocol.
:param producer: A Twisted push or pull producer.
:type producer: object
:param streaming: Producer type.
:type streaming: bool'
| def registerProducer(self, producer, streaming):
| self.transport.registerProducer(producer, streaming)
|
'Implements :func:`autobahn.wamp.interfaces.ITransport.get_channel_id`'
| def get_channel_id(self, channel_id_type=u'tls-unique'):
| return transport_channel_id(self.transport, is_server=True, channel_id_type=channel_id_type)
|
'Implements :func:`autobahn.wamp.interfaces.ITransport.get_channel_id`'
| def get_channel_id(self, channel_id_type=u'tls-unique'):
| return transport_channel_id(self.transport, is_server=False, channel_id_type=channel_id_type)
|
'.. note::
In addition to all arguments to the constructor of
:meth:`autobahn.websocket.interfaces.IWebSocketServerChannelFactory`,
you can supply a ``reactor`` keyword argument to specify the
Twisted reactor to be used.'
| def __init__(self, *args, **kwargs):
| reactor = kwargs.pop('reactor', None)
if (reactor is None):
from twisted.internet import reactor
self.reactor = reactor
protocol.WebSocketServerFactory.__init__(self, *args, **kwargs)
|
'.. note::
In addition to all arguments to the constructor of
:func:`autobahn.websocket.interfaces.IWebSocketClientChannelFactory`,
you can supply a ``reactor`` keyword argument to specify the
Twisted reactor to be used.'
| def __init__(self, *args, **kwargs):
| reactor = kwargs.pop('reactor', None)
if (reactor is None):
from twisted.internet import reactor
self.reactor = reactor
protocol.WebSocketClientFactory.__init__(self, *args, **kwargs)
|
':param factory: Stream-based factory to be wrapped.
:type factory: A subclass of ``twisted.internet.protocol.Factory``
:param url: WebSocket URL of the server this server factory will work for.
:type url: unicode'
| def __init__(self, factory, url, reactor=None, enableCompression=True, autoFragmentSize=0, subprotocol=None):
| self._factory = factory
self._subprotocols = [u'binary', u'base64']
if subprotocol:
self._subprotocols.append(subprotocol)
WebSocketServerFactory.__init__(self, url=url, reactor=reactor, protocols=self._subprotocols)
self.setProtocolOptions(autoFragmentSize=autoFragmentSize)
self.setProt... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.