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('protocol accepted must be from the list client sent or None')
self.websocket_protocol_in_use = protocol
key = self._wskey
self.websocket_extensions_in_use = []
extensionResponse = []
pmceOffers = []
for (extension, params) in self.websocket_extensions:
self.log.debug("parsed WebSocket extension '{extension}' with params '{params}'", extension=extension, params=params)
if (extension in PERMESSAGE_COMPRESSION_EXTENSION):
PMCE = PERMESSAGE_COMPRESSION_EXTENSION[extension]
try:
offer = PMCE['Offer'].parse(params)
pmceOffers.append(offer)
except Exception as e:
return self.failHandshake(str(e))
else:
self.log.debug("client requested '{extension}' extension we don't support or which is not activated", extension=extension)
if (len(pmceOffers) > 0):
accept = self.perMessageCompressionAccept(pmceOffers)
if (accept is not None):
PMCE = PERMESSAGE_COMPRESSION_EXTENSION[accept.EXTENSION_NAME]
self._perMessageCompress = PMCE['PMCE'].create_from_offer_accept(self.factory.isServer, accept)
self.websocket_extensions_in_use.append(self._perMessageCompress)
extensionResponse.append(accept.get_extension_string())
else:
self.log.debug('client request permessage-compress extension, but we did not accept any offer [{offers}]', offers=pmceOffers)
response = 'HTTP/1.1 101 Switching Protocols\r\n'
if self.factory.server:
response += ('Server: %s\r\n' % self.factory.server)
response += 'Upgrade: WebSocket\r\n'
response += 'Connection: Upgrade\r\n'
for headers_source in (self.factory.headers.items(), headers.items()):
for uh in headers_source:
if isinstance(uh[1], six.string_types):
header_values = [uh[1]]
else:
try:
header_values = iter(uh[1])
except TypeError:
header_values = [uh[1]]
for header_value in header_values:
response += ('%s: %s\r\n' % (uh[0], header_value))
if (self.websocket_protocol_in_use is not None):
response += ('Sec-WebSocket-Protocol: %s\r\n' % str(self.websocket_protocol_in_use))
sha1 = hashlib.sha1()
sha1.update((key.encode('utf8') + WebSocketProtocol._WS_MAGIC))
sec_websocket_accept = base64.b64encode(sha1.digest())
response += ('Sec-WebSocket-Accept: %s\r\n' % sec_websocket_accept.decode())
if (len(extensionResponse) > 0):
response += ('Sec-WebSocket-Extensions: %s\r\n' % ', '.join(extensionResponse))
response += '\r\n'
response_body = None
self.log.debug('sending HTTP response:\n\n{response}', response=response)
self.sendData(response.encode('utf8'))
if response_body:
self.log.debug('sending HTTP response body:\n\n{octets}', octets=_LazyHexFormatter(response_body))
self.sendData(response_body)
self.http_response_data = response
self.state = WebSocketProtocol.STATE_OPEN
if (self.openHandshakeTimeoutCall is not None):
self.log.debug('openHandshakeTimeoutCall.cancel')
self.openHandshakeTimeoutCall.cancel()
self.openHandshakeTimeoutCall = None
self.inside_message = False
self.current_frame = None
if self.autoPingInterval:
self.autoPingPendingCall = self.factory._batched_timer.call_later(self.autoPingInterval, self._sendAutoPing)
if self.trackedTimings:
self.trackedTimings.track('onOpen')
self._onOpen()
if (len(self.data) > 0):
self.consumeData()
|
'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-Length: %d\r\n' % len(responseBody))
response += '\r\n'
self.sendData(response.encode('utf8'))
self.sendData(responseBody)
|
'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.countConnections = 0
|
'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 = resource
self.path = path
self.params = params
self.protocols = (protocols or [])
self.server = server
self.headers = (headers or {})
if externalPort:
self.externalPort = externalPort
elif url:
self.externalPort = self.port
else:
self.externalPort = None
|
'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.autoFragmentSize = 0
self.failByDrop = True
self.echoCloseCodeReason = False
self.openHandshakeTimeout = 5
self.closeHandshakeTimeout = 1
self.tcpNoDelay = True
self.serveFlashSocketPolicy = False
self.flashSocketPolicy = u'<cross-domain-policy>\n <allow-access-from domain="*" to-ports="*" />\n</cross-domain-policy>\x00'
self.perMessageCompressionAccept = (lambda _: None)
self.autoPingInterval = 0
self.autoPingTimeout = 0
self.autoPingSize = 4
self.allowedOrigins = ['*']
self.allowedOriginsPatterns = wildcards2patterns(self.allowedOrigins)
self.allowNullOrigin = True
self.maxConnections = 0
self.trustXForwardedFor = 0
|
'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, closeHandshakeTimeout=None, tcpNoDelay=None, perMessageCompressionAccept=None, autoPingInterval=None, autoPingTimeout=None, autoPingSize=None, serveFlashSocketPolicy=None, flashSocketPolicy=None, allowedOrigins=None, allowNullOrigin=False, maxConnections=None, trustXForwardedFor=None):
| 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 (set(versions) != set(self.versions)):
self.versions = versions
if ((webStatus is not None) and (webStatus != self.webStatus)):
self.webStatus = webStatus
if ((utf8validateIncoming is not None) and (utf8validateIncoming != self.utf8validateIncoming)):
self.utf8validateIncoming = utf8validateIncoming
if ((requireMaskedClientFrames is not None) and (requireMaskedClientFrames != self.requireMaskedClientFrames)):
self.requireMaskedClientFrames = requireMaskedClientFrames
if ((maskServerFrames is not None) and (maskServerFrames != self.maskServerFrames)):
self.maskServerFrames = maskServerFrames
if ((applyMask is not None) and (applyMask != self.applyMask)):
self.applyMask = applyMask
if ((maxFramePayloadSize is not None) and (maxFramePayloadSize != self.maxFramePayloadSize)):
self.maxFramePayloadSize = maxFramePayloadSize
if ((maxMessagePayloadSize is not None) and (maxMessagePayloadSize != self.maxMessagePayloadSize)):
self.maxMessagePayloadSize = maxMessagePayloadSize
if ((autoFragmentSize is not None) and (autoFragmentSize != self.autoFragmentSize)):
self.autoFragmentSize = autoFragmentSize
if ((failByDrop is not None) and (failByDrop != self.failByDrop)):
self.failByDrop = failByDrop
if ((echoCloseCodeReason is not None) and (echoCloseCodeReason != self.echoCloseCodeReason)):
self.echoCloseCodeReason = echoCloseCodeReason
if ((openHandshakeTimeout is not None) and (openHandshakeTimeout != self.openHandshakeTimeout)):
self.openHandshakeTimeout = openHandshakeTimeout
if ((closeHandshakeTimeout is not None) and (closeHandshakeTimeout != self.closeHandshakeTimeout)):
self.closeHandshakeTimeout = closeHandshakeTimeout
if ((tcpNoDelay is not None) and (tcpNoDelay != self.tcpNoDelay)):
self.tcpNoDelay = tcpNoDelay
if ((perMessageCompressionAccept is not None) and (perMessageCompressionAccept != self.perMessageCompressionAccept)):
self.perMessageCompressionAccept = perMessageCompressionAccept
if ((autoPingInterval is not None) and (autoPingInterval != self.autoPingInterval)):
self.autoPingInterval = autoPingInterval
if ((autoPingTimeout is not None) and (autoPingTimeout != self.autoPingTimeout)):
self.autoPingTimeout = autoPingTimeout
if ((autoPingSize is not None) and (autoPingSize != self.autoPingSize)):
assert ((type(autoPingSize) == float) or (type(autoPingSize) in six.integer_types))
assert (4 <= autoPingSize <= 125)
self.autoPingSize = autoPingSize
if ((serveFlashSocketPolicy is not None) and (serveFlashSocketPolicy != self.serveFlashSocketPolicy)):
self.serveFlashSocketPolicy = serveFlashSocketPolicy
if ((flashSocketPolicy is not None) and (flashSocketPolicy != self.flashSocketPolicy)):
self.flashSocketPolicy = flashSocketPolicy
if ((allowedOrigins is not None) and (allowedOrigins != self.allowedOrigins)):
self.allowedOrigins = allowedOrigins
self.allowedOriginsPatterns = wildcards2patterns(self.allowedOrigins)
if (allowNullOrigin not in [True, False]):
raise ValueError('allowNullOrigin must be a bool')
self.allowNullOrigin = allowNullOrigin
if ((maxConnections is not None) and (maxConnections != self.maxConnections)):
assert (type(maxConnections) in six.integer_types)
assert (maxConnections >= 0)
self.maxConnections = maxConnections
if ((trustXForwardedFor is not None) and (trustXForwardedFor != self.trustXForwardedFor)):
assert (type(trustXForwardedFor) in six.integer_types)
assert (trustXForwardedFor >= 0)
self.trustXForwardedFor = trustXForwardedFor
|
'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(http_response_data)
self.log.debug('received HTTP status line for proxy connect request : {status}', status=http_status_line)
self.log.debug('received HTTP headers for proxy connect request : {headers}', headers=http_headers)
sl = http_status_line.split()
if (len(sl) < 2):
return self.failProxyConnect(("Bad HTTP response status line '%s'" % http_status_line))
http_version = sl[0].strip()
if (http_version not in ('HTTP/1.1', 'HTTP/1.0')):
return self.failProxyConnect(("Unsupported HTTP version ('%s')" % http_version))
try:
status_code = int(sl[1].strip())
except ValueError:
return self.failProxyConnect(("Bad HTTP status code ('%s')" % sl[1].strip()))
if (not (200 <= status_code < 300)):
if (len(sl) > 2):
reason = (' - %s' % ''.join(sl[2:]))
else:
reason = ''
return self.failProxyConnect(('HTTP proxy connect failed (%d%s)' % (status_code, reason)))
self.data = self.data[(end_of_header + 4):]
self.state = WebSocketProtocol.STATE_CONNECTING
if (len(self.data) > 0):
self.consumeData()
if self.factory.isSecure:
self.startTLS()
self.startHandshake()
|
'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 += 'Upgrade: WebSocket\r\n'
request += 'Connection: Upgrade\r\n'
request += 'Pragma: no-cache\r\n'
request += 'Cache-Control: no-cache\r\n'
for uh in self.factory.headers.items():
request += ('%s: %s\r\n' % (uh[0], uh[1]))
self.websocket_key = base64.b64encode(os.urandom(16))
request += ('Sec-WebSocket-Key: %s\r\n' % self.websocket_key.decode())
if self.factory.origin:
if (self.version > 10):
request += ('Origin: %s\r\n' % self.factory.origin)
else:
request += ('Sec-WebSocket-Origin: %s\r\n' % self.factory.origin)
if (len(self.factory.protocols) > 0):
request += ('Sec-WebSocket-Protocol: %s\r\n' % ','.join(self.factory.protocols))
extensions = []
for offer in self.perMessageCompressionOffers:
extensions.append(offer.get_extension_string())
if (len(extensions) > 0):
request += ('Sec-WebSocket-Extensions: %s\r\n' % ', '.join(extensions))
request += ('Sec-WebSocket-Version: %d\r\n' % WebSocketProtocol.SPEC_TO_PROTOCOL_VERSION[self.version])
request += '\r\n'
self.http_request_data = request.encode('utf8')
self.sendData(self.http_request_data)
self.log.debug('{request}', request=request)
|
'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) = parseHttpHeader(self.http_response_data)
self.log.debug('received HTTP status line in opening handshake : {status}', status=self.http_status_line)
self.log.debug('received HTTP headers in opening handshake : {headers}', headers=self.http_headers)
sl = self.http_status_line.split()
if (len(sl) < 2):
return self.failHandshake(("Bad HTTP response status line '%s'" % self.http_status_line))
http_version = sl[0].strip()
if (http_version != 'HTTP/1.1'):
return self.failHandshake(("Unsupported HTTP version ('%s')" % http_version))
try:
status_code = int(sl[1].strip())
except ValueError:
return self.failHandshake(("Bad HTTP status code ('%s')" % sl[1].strip()))
if (status_code != 101):
if (len(sl) > 2):
reason = (' - %s' % ''.join(sl[2:]))
else:
reason = ''
return self.failHandshake(('WebSocket connection upgrade failed (%d%s)' % (status_code, reason)))
if ('upgrade' not in self.http_headers):
return self.failHandshake('HTTP Upgrade header missing')
if (self.http_headers['upgrade'].strip().lower() != 'websocket'):
return self.failHandshake(("HTTP Upgrade header different from 'websocket' (case-insensitive) : %s" % self.http_headers['upgrade']))
if ('connection' not in self.http_headers):
return self.failHandshake('HTTP Connection header missing')
connectionUpgrade = False
for c in self.http_headers['connection'].split(','):
if (c.strip().lower() == 'upgrade'):
connectionUpgrade = True
break
if (not connectionUpgrade):
return self.failHandshake(("HTTP Connection header does not include 'upgrade' value (case-insensitive) : %s" % self.http_headers['connection']))
if ('sec-websocket-accept' not in self.http_headers):
return self.failHandshake('HTTP Sec-WebSocket-Accept header missing in opening handshake reply')
else:
if (http_headers_cnt['sec-websocket-accept'] > 1):
return self.failHandshake('HTTP Sec-WebSocket-Accept header appears more than once in opening handshake reply')
sec_websocket_accept_got = self.http_headers['sec-websocket-accept'].strip()
sha1 = hashlib.sha1()
sha1.update((self.websocket_key + WebSocketProtocol._WS_MAGIC))
sec_websocket_accept = base64.b64encode(sha1.digest()).decode()
if (sec_websocket_accept_got != sec_websocket_accept):
return self.failHandshake(('HTTP Sec-WebSocket-Accept bogus value : expected %s / got %s' % (sec_websocket_accept, sec_websocket_accept_got)))
self.websocket_extensions_in_use = []
if ('sec-websocket-extensions' in self.http_headers):
if (http_headers_cnt['sec-websocket-extensions'] > 1):
return self.failHandshake('HTTP Sec-WebSocket-Extensions header appears more than once in opening handshake reply')
else:
websocket_extensions = self._parseExtensionsHeader(self.http_headers['sec-websocket-extensions'])
for (extension, params) in websocket_extensions:
self.log.debug("parsed WebSocket extension '{extension}' with params '{params}'", extension=extension, params=params)
if (extension in PERMESSAGE_COMPRESSION_EXTENSION):
if (self._perMessageCompress is not None):
return self.failHandshake('multiple occurrence of a permessage-compress extension')
PMCE = PERMESSAGE_COMPRESSION_EXTENSION[extension]
try:
pmceResponse = PMCE['Response'].parse(params)
except Exception as e:
return self.failHandshake(str(e))
accept = self.perMessageCompressionAccept(pmceResponse)
if (accept is None):
return self.failHandshake('WebSocket permessage-compress extension response from server denied by client')
self._perMessageCompress = PMCE['PMCE'].create_from_response_accept(self.factory.isServer, accept)
self.websocket_extensions_in_use.append(self._perMessageCompress)
else:
return self.failHandshake(("server wants to use extension '%s' we did not request, haven't implemented or did not enable" % extension))
self.websocket_protocol_in_use = None
if ('sec-websocket-protocol' in self.http_headers):
if (http_headers_cnt['sec-websocket-protocol'] > 1):
return self.failHandshake('HTTP Sec-WebSocket-Protocol header appears more than once in opening handshake reply')
sp = str(self.http_headers['sec-websocket-protocol'].strip())
if (sp != ''):
if (sp not in self.factory.protocols):
return self.failHandshake(('subprotocol selected by server (%s) not in subprotocol list requested by client (%s)' % (sp, str(self.factory.protocols))))
else:
self.websocket_protocol_in_use = sp
self.data = self.data[(end_of_header + 4):]
self.state = WebSocketProtocol.STATE_OPEN
if (self.openHandshakeTimeoutCall is not None):
self.log.debug('openHandshakeTimeoutCall.cancel')
self.openHandshakeTimeoutCall.cancel()
self.openHandshakeTimeoutCall = None
self.inside_message = False
self.current_frame = None
self.websocket_version = self.version
if self.autoPingInterval:
self.autoPingPendingCall = self.factory._batched_timer.call_later(self.autoPingInterval, self._sendAutoPing)
try:
response = ConnectionResponse(self.peer, self.http_headers, self.websocket_version, self.websocket_protocol_in_use, self.websocket_extensions_in_use)
self._onConnect(response)
except Exception as e:
self._fail_connection(1000, u'{}'.format(e))
else:
if self.trackedTimings:
self.trackedTimings.track('onOpen')
self._onOpen()
if (len(self.data) > 0):
self.consumeData()
|
'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 [])
self.useragent = useragent
self.headers = (headers or {})
self.proxy = proxy
|
'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
self.echoCloseCodeReason = False
self.serverConnectionDropTimeout = 1
self.openHandshakeTimeout = 5
self.closeHandshakeTimeout = 1
self.tcpNoDelay = True
self.perMessageCompressionOffers = []
self.perMessageCompressionAccept = (lambda _: None)
self.autoPingInterval = 0
self.autoPingTimeout = 0
self.autoPingSize = 4
|
'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, closeHandshakeTimeout=None, tcpNoDelay=None, perMessageCompressionOffers=None, perMessageCompressionAccept=None, autoPingInterval=None, autoPingTimeout=None, autoPingSize=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):
self.version = version
if ((utf8validateIncoming is not None) and (utf8validateIncoming != self.utf8validateIncoming)):
self.utf8validateIncoming = utf8validateIncoming
if ((acceptMaskedServerFrames is not None) and (acceptMaskedServerFrames != self.acceptMaskedServerFrames)):
self.acceptMaskedServerFrames = acceptMaskedServerFrames
if ((maskClientFrames is not None) and (maskClientFrames != self.maskClientFrames)):
self.maskClientFrames = maskClientFrames
if ((applyMask is not None) and (applyMask != self.applyMask)):
self.applyMask = applyMask
if ((maxFramePayloadSize is not None) and (maxFramePayloadSize != self.maxFramePayloadSize)):
self.maxFramePayloadSize = maxFramePayloadSize
if ((maxMessagePayloadSize is not None) and (maxMessagePayloadSize != self.maxMessagePayloadSize)):
self.maxMessagePayloadSize = maxMessagePayloadSize
if ((autoFragmentSize is not None) and (autoFragmentSize != self.autoFragmentSize)):
self.autoFragmentSize = autoFragmentSize
if ((failByDrop is not None) and (failByDrop != self.failByDrop)):
self.failByDrop = failByDrop
if ((echoCloseCodeReason is not None) and (echoCloseCodeReason != self.echoCloseCodeReason)):
self.echoCloseCodeReason = echoCloseCodeReason
if ((serverConnectionDropTimeout is not None) and (serverConnectionDropTimeout != self.serverConnectionDropTimeout)):
self.serverConnectionDropTimeout = serverConnectionDropTimeout
if ((openHandshakeTimeout is not None) and (openHandshakeTimeout != self.openHandshakeTimeout)):
self.openHandshakeTimeout = openHandshakeTimeout
if ((closeHandshakeTimeout is not None) and (closeHandshakeTimeout != self.closeHandshakeTimeout)):
self.closeHandshakeTimeout = closeHandshakeTimeout
if ((tcpNoDelay is not None) and (tcpNoDelay != self.tcpNoDelay)):
self.tcpNoDelay = tcpNoDelay
if ((perMessageCompressionOffers is not None) and (pickle.dumps(perMessageCompressionOffers) != pickle.dumps(self.perMessageCompressionOffers))):
if (type(perMessageCompressionOffers) == list):
self.perMessageCompressionOffers = copy.deepcopy(perMessageCompressionOffers)
else:
raise Exception(('invalid type %s for perMessageCompressionOffers - expected list' % type(perMessageCompressionOffers)))
if ((perMessageCompressionAccept is not None) and (perMessageCompressionAccept != self.perMessageCompressionAccept)):
self.perMessageCompressionAccept = perMessageCompressionAccept
if ((autoPingInterval is not None) and (autoPingInterval != self.autoPingInterval)):
self.autoPingInterval = autoPingInterval
if ((autoPingTimeout is not None) and (autoPingTimeout != self.autoPingTimeout)):
self.autoPingTimeout = autoPingTimeout
if ((autoPingSize is not None) and (autoPingSize != self.autoPingSize)):
assert ((type(autoPingSize) == float) or (type(autoPingSize) in six.integer_types))
assert (4 <= autoPingSize <= 125)
self.autoPingSize = autoPingSize
|
'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'" % (p, cls.EXTENSION_NAME)))
val = params[p][0]
if (p == 'client_max_window_bits'):
if (val is not True):
try:
val = int(val)
except:
raise Exception(("illegal extension parameter value '%s' for parameter '%s' of extension '%s'" % (val, p, cls.EXTENSION_NAME)))
else:
if (val not in PerMessageDeflateMixin.WINDOW_SIZE_PERMISSIBLE_VALUES):
raise Exception(("illegal extension parameter value '%s' for parameter '%s' of extension '%s'" % (val, p, cls.EXTENSION_NAME)))
else:
accept_max_window_bits = True
else:
accept_max_window_bits = True
elif (p == 'client_no_context_takeover'):
if (val is not True):
raise Exception(("illegal extension parameter value '%s' for parameter '%s' of extension '%s'" % (val, p, cls.EXTENSION_NAME)))
else:
accept_no_context_takeover = True
elif (p == 'server_max_window_bits'):
try:
val = int(val)
except:
raise Exception(("illegal extension parameter value '%s' for parameter '%s' of extension '%s'" % (val, p, cls.EXTENSION_NAME)))
else:
if (val not in PerMessageDeflateMixin.WINDOW_SIZE_PERMISSIBLE_VALUES):
raise Exception(("illegal extension parameter value '%s' for parameter '%s' of extension '%s'" % (val, p, cls.EXTENSION_NAME)))
else:
request_max_window_bits = val
elif (p == 'server_no_context_takeover'):
if (val is not True):
raise Exception(("illegal extension parameter value '%s' for parameter '%s' of extension '%s'" % (val, p, cls.EXTENSION_NAME)))
else:
request_no_context_takeover = True
else:
raise Exception(("illegal extension parameter '%s' for extension '%s'" % (p, cls.EXTENSION_NAME)))
offer = cls(accept_no_context_takeover, accept_max_window_bits, request_no_context_takeover, request_max_window_bits)
return offer
|
':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``, the client request the "no context takeover" feature.
:type request_no_context_takeover: bool
:param request_max_window_bits: When non-zero, the client requests the given "max window size" (must be
and integer from the interval ``[8..15]``).
:type request_max_window_bits: int'
| 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 type %s for accept_max_window_bits' % type(accept_max_window_bits)))
self.accept_max_window_bits = accept_max_window_bits
if (type(request_no_context_takeover) != bool):
raise Exception(('invalid type %s for request_no_context_takeover' % type(request_no_context_takeover)))
self.request_no_context_takeover = request_no_context_takeover
if ((request_max_window_bits != 0) and (request_max_window_bits not in self.WINDOW_SIZE_PERMISSIBLE_VALUES)):
raise Exception(('invalid value %s for request_max_window_bits - permissible values %s' % (request_max_window_bits, self.WINDOW_SIZE_PERMISSIBLE_VALUES)))
self.request_max_window_bits = request_max_window_bits
|
'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'
if (self.request_max_window_bits != 0):
pmce_string += ('; server_max_window_bits=%d' % self.request_max_window_bits)
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, '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_bits))
|
':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 requests the given "max window size" (must be
and integer from the interval ``[8..15]``).
:param request_max_window_bits: int
:param no_context_takeover: Override server ("server-to-client direction") context takeover (this must
be compatible with the offer).
:type no_context_takeover: bool
:param window_bits: Override server ("server-to-client direction") window size (this must be
compatible with the offer).
:type window_bits: int
:param mem_level: Set server ("server-to-client direction") memory level.
:type mem_level: int'
| 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_context_takeover)))
if (request_no_context_takeover and (not offer.accept_no_context_takeover)):
raise Exception(('invalid value %s for request_no_context_takeover - feature unsupported by client' % request_no_context_takeover))
self.request_no_context_takeover = request_no_context_takeover
if ((request_max_window_bits != 0) and (request_max_window_bits not in self.WINDOW_SIZE_PERMISSIBLE_VALUES)):
raise Exception(('invalid value %s for request_max_window_bits - permissible values %s' % (request_max_window_bits, self.WINDOW_SIZE_PERMISSIBLE_VALUES)))
if ((request_max_window_bits != 0) and (not offer.accept_max_window_bits)):
raise Exception(('invalid value %s for request_max_window_bits - feature unsupported by client' % request_max_window_bits))
self.request_max_window_bits = request_max_window_bits
if (no_context_takeover is not None):
if (type(no_context_takeover) != bool):
raise Exception(('invalid type %s for no_context_takeover' % type(no_context_takeover)))
if (offer.request_no_context_takeover and (not no_context_takeover)):
raise Exception(('invalid value %s for no_context_takeover - client requested feature' % no_context_takeover))
self.no_context_takeover = no_context_takeover
if (window_bits is not None):
if (window_bits not in self.WINDOW_SIZE_PERMISSIBLE_VALUES):
raise Exception(('invalid value %s for window_bits - permissible values %s' % (window_bits, self.WINDOW_SIZE_PERMISSIBLE_VALUES)))
if ((offer.request_max_window_bits != 0) and (window_bits > offer.request_max_window_bits)):
raise Exception(('invalid value %s for window_bits - client requested lower maximum value' % window_bits))
self.window_bits = window_bits
if (mem_level is not None):
if (mem_level not in self.MEM_LEVEL_PERMISSIBLE_VALUES):
raise Exception(('invalid value %s for mem_level - permissible values %s' % (mem_level, self.MEM_LEVEL_PERMISSIBLE_VALUES)))
self.mem_level = mem_level
|
'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_takeover:
pmce_string += '; client_no_context_takeover'
if (self.request_max_window_bits != 0):
pmce_string += ('; client_max_window_bits=%d' % self.request_max_window_bits)
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, '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, self.no_context_takeover, self.window_bits, self.mem_level))
|
'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, cls.EXTENSION_NAME)))
val = params[p][0]
if (p == 'client_max_window_bits'):
try:
val = int(val)
except:
raise Exception(("illegal extension parameter value '%s' for parameter '%s' of extension '%s'" % (val, p, cls.EXTENSION_NAME)))
else:
if (val not in PerMessageDeflateMixin.WINDOW_SIZE_PERMISSIBLE_VALUES):
raise Exception(("illegal extension parameter value '%s' for parameter '%s' of extension '%s'" % (val, p, cls.EXTENSION_NAME)))
else:
client_max_window_bits = val
elif (p == 'client_no_context_takeover'):
if (val is not True):
raise Exception(("illegal extension parameter value '%s' for parameter '%s' of extension '%s'" % (val, p, cls.EXTENSION_NAME)))
else:
client_no_context_takeover = True
elif (p == 'server_max_window_bits'):
try:
val = int(val)
except:
raise Exception(("illegal extension parameter value '%s' for parameter '%s' of extension '%s'" % (val, p, cls.EXTENSION_NAME)))
else:
if (val not in PerMessageDeflateMixin.WINDOW_SIZE_PERMISSIBLE_VALUES):
raise Exception(("illegal extension parameter value '%s' for parameter '%s' of extension '%s'" % (val, p, cls.EXTENSION_NAME)))
else:
server_max_window_bits = val
elif (p == 'server_no_context_takeover'):
if (val is not True):
raise Exception(("illegal extension parameter value '%s' for parameter '%s' of extension '%s'" % (val, p, cls.EXTENSION_NAME)))
else:
server_no_context_takeover = True
else:
raise Exception(("illegal extension parameter '%s' for extension '%s'" % (p, cls.EXTENSION_NAME)))
response = cls(client_max_window_bits, client_no_context_takeover, server_max_window_bits, server_no_context_takeover)
return response
|
':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_takeover))
|
':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: Override client ("client-to-server direction") window size (this must be compatible with response).
:type window_bits: int
:param mem_level: Set client ("client-to-server direction") memory level.
:type mem_level: int'
| 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 for no_context_takeover' % type(no_context_takeover)))
if (response.client_no_context_takeover and (not no_context_takeover)):
raise Exception(('invalid value %s for no_context_takeover - server requested feature' % no_context_takeover))
self.no_context_takeover = no_context_takeover
if (window_bits is not None):
if (window_bits not in self.WINDOW_SIZE_PERMISSIBLE_VALUES):
raise Exception(('invalid value %s for window_bits - permissible values %s' % (window_bits, self.WINDOW_SIZE_PERMISSIBLE_VALUES)))
if ((response.client_max_window_bits != 0) and (window_bits > response.client_max_window_bits)):
raise Exception(('invalid value %s for window_bits - server requested lower maximum value' % window_bits))
self.window_bits = window_bits
if (mem_level is not None):
if (mem_level not in self.MEM_LEVEL_PERMISSIBLE_VALUES):
raise Exception(('invalid value %s for mem_level - permissible values %s' % (mem_level, self.MEM_LEVEL_PERMISSIBLE_VALUES)))
self.mem_level = mem_level
|
'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 (p == 'client_no_context_takeover'):
if (val is not True):
raise Exception(("illegal extension parameter value '%s' for parameter '%s' of extension '%s'" % (val, p, cls.EXTENSION_NAME)))
else:
accept_no_context_takeover = True
elif (p == 'server_no_context_takeover'):
if (val is not True):
raise Exception(("illegal extension parameter value '%s' for parameter '%s' of extension '%s'" % (val, p, cls.EXTENSION_NAME)))
else:
request_no_context_takeover = True
else:
raise Exception(("illegal extension parameter '%s' for extension '%s'" % (p, cls.EXTENSION_NAME)))
offer = cls(accept_no_context_takeover, request_no_context_takeover)
return offer
|
':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(('invalid type %s for request_no_context_takeover' % type(request_no_context_takeover)))
self.request_no_context_takeover = request_no_context_takeover
|
'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") context takeover (this must be compatible with offer).
:type no_context_takeover: bool'
| 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_context_takeover)))
if (request_no_context_takeover and (not offer.accept_no_context_takeover)):
raise Exception(('invalid value %s for request_no_context_takeover - feature unsupported by client' % request_no_context_takeover))
self.request_no_context_takeover = request_no_context_takeover
if (no_context_takeover is not None):
if (type(no_context_takeover) != bool):
raise Exception(('invalid type %s for no_context_takeover' % type(no_context_takeover)))
if (offer.request_no_context_takeover and (not no_context_takeover)):
raise Exception(('invalid value %s for no_context_takeover - client requested feature' % no_context_takeover))
self.no_context_takeover = no_context_takeover
|
'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 (p == 'client_no_context_takeover'):
if (val is not True):
raise Exception(("illegal extension parameter value '%s' for parameter '%s' of extension '%s'" % (val, p, cls.EXTENSION_NAME)))
else:
client_no_context_takeover = True
elif (p == 'server_no_context_takeover'):
if (val is not True):
raise Exception(("illegal extension parameter value '%s' for parameter '%s' of extension '%s'" % (val, p, cls.EXTENSION_NAME)))
else:
server_no_context_takeover = True
else:
raise Exception(("illegal extension parameter '%s' for extension '%s'" % (p, cls.EXTENSION_NAME)))
response = cls(client_no_context_takeover, server_no_context_takeover)
return response
|
'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 for no_context_takeover' % type(no_context_takeover)))
if (response.client_no_context_takeover and (not no_context_takeover)):
raise Exception(('invalid value %s for no_context_takeover - server requested feature' % no_context_takeover))
self.no_context_takeover = no_context_takeover
|
'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 == 'client_max_compress_level'):
if (val is not True):
raise Exception(("illegal extension parameter value '%s' for parameter '%s' of extension '%s'" % (val, p, cls.EXTENSION_NAME)))
else:
accept_max_compress_level = True
elif (p == 'server_max_compress_level'):
try:
val = int(val)
except:
raise Exception(("illegal extension parameter value '%s' for parameter '%s' of extension '%s'" % (val, p, cls.EXTENSION_NAME)))
if (val not in PerMessageBzip2Mixin.COMPRESS_LEVEL_PERMISSIBLE_VALUES):
raise Exception(("illegal extension parameter value '%s' for parameter '%s' of extension '%s'" % (val, p, cls.EXTENSION_NAME)))
else:
request_max_compress_level = val
else:
raise Exception(("illegal extension parameter '%s' for extension '%s'" % (p, cls.EXTENSION_NAME)))
offer = cls(accept_max_compress_level, request_max_compress_level)
return offer
|
'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.COMPRESS_LEVEL_PERMISSIBLE_VALUES)):
raise Exception(('invalid value %s for request_max_compress_level - permissible values %s' % (request_max_compress_level, self.COMPRESS_LEVEL_PERMISSIBLE_VALUES)))
self.request_max_compress_level = request_max_compress_level
|
'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 ("server-to-client direction") compress level (this must be compatible with offer).
:type compress_level: int'
| 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 value %s for request_max_compress_level - permissible values %s' % (request_max_compress_level, self.COMPRESS_LEVEL_PERMISSIBLE_VALUES)))
if ((request_max_compress_level != 0) and (not offer.accept_max_compress_level)):
raise Exception(('invalid value %s for request_max_compress_level - feature unsupported by client' % request_max_compress_level))
self.request_max_compress_level = request_max_compress_level
if (compress_level is not None):
if (compress_level not in self.COMPRESS_LEVEL_PERMISSIBLE_VALUES):
raise Exception(('invalid value %s for compress_level - permissible values %s' % (compress_level, self.COMPRESS_LEVEL_PERMISSIBLE_VALUES)))
if ((offer.request_max_compress_level != 0) and (compress_level > offer.request_max_compress_level)):
raise Exception(('invalid value %s for compress_level - client requested lower maximum value' % compress_level))
self.compress_level = compress_level
|
'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_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, '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 == 'client_max_compress_level'):
try:
val = int(val)
except:
raise Exception(("illegal extension parameter value '%s' for parameter '%s' of extension '%s'" % (val, p, cls.EXTENSION_NAME)))
if (val not in PerMessageBzip2Mixin.COMPRESS_LEVEL_PERMISSIBLE_VALUES):
raise Exception(("illegal extension parameter value '%s' for parameter '%s' of extension '%s'" % (val, p, cls.EXTENSION_NAME)))
else:
client_max_compress_level = val
elif (p == 'server_max_compress_level'):
try:
val = int(val)
except:
raise Exception(("illegal extension parameter value '%s' for parameter '%s' of extension '%s'" % (val, p, cls.EXTENSION_NAME)))
if (val not in PerMessageBzip2Mixin.COMPRESS_LEVEL_PERMISSIBLE_VALUES):
raise Exception(("illegal extension parameter value '%s' for parameter '%s' of extension '%s'" % (val, p, cls.EXTENSION_NAME)))
else:
server_max_compress_level = val
else:
raise Exception(("illegal extension parameter '%s' for extension '%s'" % (p, cls.EXTENSION_NAME)))
response = cls(client_max_compress_level, server_max_compress_level)
return response
|
'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(('invalid value %s for compress_level - permissible values %s' % (compress_level, self.COMPRESS_LEVEL_PERMISSIBLE_VALUES)))
if ((response.client_max_compress_level != 0) and (compress_level > response.client_max_compress_level)):
raise Exception(('invalid value %s for compress_level - server requested lower maximum value' % compress_level))
self.compress_level = compress_level
|
'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. For example, a resource URI of
``/myservice?foo=23&foo=66&bar=2`` will be parsed to ``/myservice``.
:type path: str
:param params: Query parameters (if any) from requested HTTP resource URI.
For example, a resource URI of ``/myservice?foo=23&foo=66&bar=2`` will be
parsed to ``{\'foo\': [\'23\', \'66\'], \'bar\': [\'2\']}``.
:type params: dict
:param version: The WebSocket protocol version the client announced (and will be
spoken, when connection is accepted).
:type version: int
:param origin: The WebSocket origin header or None. Note that this only
a reliable source of information for browser clients!
:type origin: str
:param protocols: The WebSocket (sub)protocols the client announced. You must
select and return one of those (or ``None``) in
:meth:`autobahn.websocket.WebSocketServerProtocol.onConnect`.
:type protocols: list
:param extensions: The WebSocket extensions the client requested and the
server accepted, and thus will be spoken, once the WebSocket connection
has been fully established.
:type extensions: list'
| 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 WebSocket (sub)protocol in use.
:type protocol: str
:param extensions: The WebSocket extensions in use.
:type extensions: list of str'
| 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 the values either unicode or tuple/list. In the latter case
a separate HTTP header line will be sent for each item in
tuple/list.
:type headers: dict or None'
| 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 (type(v) == tuple))
if ((type(v) == list) or (type(v) == tuple)):
for vv in v:
assert (type(vv) == six.text_type)
self.subprotocol = subprotocol
self.headers = headers
|
':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 effect when WebSocket compression has been negotiated
on the WebSocket connection. Use when you know the payload is
incompressible (e.g. encrypted or already compressed).
:type skip_compress: bool'
| 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) - must be <= 125 bytes'.format(len(payload))
self.payload = payload
|
'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;
- ``.stop()`` was called, and completed successfully;
- none of our transports were able to connect successfully (failure);
:returns: a Deferred that fires (with ``None``) when we are
"done" or with a Failure if something went wrong.'
| @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:
transport = next(transport_gen)
if transport.can_reconnect():
delay = transport.next_delay()
self.log.debug('trying transport {transport_idx} using connect delay {transport_delay}', transport_idx=transport.idx, transport_delay=delay)
(yield sleep(delay))
try:
(yield self._connect_once(reactor, transport))
except Exception as e:
f = txaio.create_failure()
self.log.error(u'component failed: {error}', error=txaio.failure_message(f))
self.log.debug(u'{tb}', tb=txaio.failure_format_traceback(f))
if isinstance(e, ApplicationError):
if (e.error in [u'wamp.error.no_such_realm']):
reconnect = False
self.log.error(u'Fatal error, not reconnecting')
raise
self.log.error(u'{msg}', msg=e.error_message())
elif _is_ssl_error(e):
for (lib, fn, reason) in e.args[0]:
self.log.error(u'TLS failure: {reason}', reason=reason)
self.log.error(u'Marking this transport as failed')
transport.failed()
else:
f = txaio.create_failure()
self.log.error(u'Connection failed: {error}', error=txaio.failure_message(f))
self.log.debug(u'{tb}', tb=txaio.failure_format_traceback(f))
else:
self.log.debug(u'Not reconnecting')
reconnect = False
elif (not self._can_reconnect()):
self.log.info('No remaining transports to try')
reconnect = False
|
'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 application payload ({0})'.format(e))
else:
self.sendString(payload)
self.log.trace('WampRawSocketProtocol: TX octets: {octets}', octets=_LazyHexFormatter(payload))
else:
raise TransportLost()
|
'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.interfaces.ISerializer`'
| 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))
serializers.append(CBORSerializer())
except ImportError:
pass
try:
from autobahn.wamp.serializer import MsgPackSerializer
serializers.append(MsgPackSerializer(batched=True))
serializers.append(MsgPackSerializer())
except ImportError:
pass
try:
from autobahn.wamp.serializer import UBJSONSerializer
serializers.append(UBJSONSerializer(batched=True))
serializers.append(UBJSONSerializer())
except ImportError:
pass
try:
from autobahn.wamp.serializer import JsonSerializer
serializers.append(JsonSerializer(batched=True))
serializers.append(JsonSerializer())
except ImportError:
pass
if (not serializers):
raise Exception('could not import any WAMP serializers')
self._serializers = {}
for ser in serializers:
self._serializers[ser.RAWSOCKET_SERIALIZER_ID] = ser
|
':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).
:type serializer: object implementing :class:`autobahn.wamp.interfaces.ISerializer`'
| 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 (serializer is None):
try:
from autobahn.wamp.serializer import MsgPackSerializer
serializer = MsgPackSerializer()
except ImportError:
pass
if (serializer is None):
try:
from autobahn.wamp.serializer import UBJSONSerializer
serializer = UBJSONSerializer()
except ImportError:
pass
if (serializer is None):
try:
from autobahn.wamp.serializer import JsonSerializer
serializer = JsonSerializer()
except ImportError:
pass
if (serializer is None):
raise Exception('could not import any WAMP serializer')
self._serializer = serializer
|
'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.setProtocolOptions(failByDrop=False)
if enableCompression:
def accept(offers):
for offer in offers:
if isinstance(offer, PerMessageDeflateOffer):
return PerMessageDeflateOfferAccept(offer)
self.setProtocolOptions(perMessageCompressionAccept=accept)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.