def test_send_message_deflate_frame_bfinal(self):
extension = common.ExtensionParameter(common.DEFLATE_FRAME_EXTENSION)
request = _create_request_from_rawdata(
'', deflate_frame_request=extension)
self.assertEquals(1, len(request.ws_extension_processors))
deflate_frame_processor = request.ws_extension_processors[0]
deflate_frame_processor.set_bfinal(True)
msgutil.send_message(request, 'Hello')
msgutil.send_message(request, 'World')
expected = ''
compress = zlib.compressobj(
zlib.Z_DEFAULT_COMPRESSION, zlib.DEFLATED, -zlib.MAX_WBITS)
compressed_hello = compress.compress('Hello')
compressed_hello += compress.flush(zlib.Z_FINISH)
compressed_hello = compressed_hello + chr(0)
expected += '\xc1%c' % len(compressed_hello)
expected += compressed_hello
compress = zlib.compressobj(
zlib.Z_DEFAULT_COMPRESSION, zlib.DEFLATED, -zlib.MAX_WBITS)
compressed_world = compress.compress('World')
compressed_world += compress.flush(zlib.Z_FINISH)
compressed_world = compressed_world + chr(0)
expected += '\xc1%c' % len(compressed_world)
expected += compressed_world
self.assertEqual(expected, request.connection.written_data())
def web_socket_transfer_data(request):
lastmsg = ''
r = redis.Redis()
timelim = time.time() + timeout
while True:
#words = msgutil.receive_message(request)
#if words == __KillerWords__:
# break
# get last 10 messages
messages = r.lrange('msgs',0,9)
try:
# give remaining messages from buffer
lastindex = messages.index(lastmsg)
if (lastindex>0):
timelim = time.time() + timeout
for i in xrange(0,lastindex):
msgutil.send_message(request,
messages[lastindex - i -1].split('|',1)[1])
except ValueError:
# client has not received anything at all, give the whole buffer
for msg in messages[::-1]:
msgutil.send_message(request, msg.split('|',1)[1])
timelim = time.time() + timeout
lastmsg = messages[0]
if (time.time() > timelim):
print "A receive timedout"
r.disconnect()
break
def test_send_message_permessage_compress_deflate_fragmented_bfinal(self):
extension = common.ExtensionParameter(
common.PERMESSAGE_COMPRESSION_EXTENSION)
extension.add_parameter('method', 'deflate')
request = _create_request_from_rawdata(
'', permessage_compression_request=extension)
self.assertEquals(1, len(request.ws_extension_processors))
compression_processor = (
request.ws_extension_processors[0].get_compression_processor())
compression_processor.set_bfinal(True)
msgutil.send_message(request, 'Hello', end=False)
msgutil.send_message(request, 'World', end=True)
expected = ''
compress = zlib.compressobj(
zlib.Z_DEFAULT_COMPRESSION, zlib.DEFLATED, -zlib.MAX_WBITS)
compressed_hello = compress.compress('Hello')
compressed_hello += compress.flush(zlib.Z_FINISH)
compressed_hello = compressed_hello + chr(0)
expected += '\x41%c' % len(compressed_hello)
expected += compressed_hello
compress = zlib.compressobj(
zlib.Z_DEFAULT_COMPRESSION, zlib.DEFLATED, -zlib.MAX_WBITS)
compressed_world = compress.compress('World')
compressed_world += compress.flush(zlib.Z_FINISH)
compressed_world = compressed_world + chr(0)
expected += '\x80%c' % len(compressed_world)
expected += compressed_world
self.assertEqual(expected, request.connection.written_data())
def web_socket_transfer_data(request):
global connections
r = request.ws_resource.split('?', 1)
if len(r) == 1:
return
param = cgi.parse_qs(r[1])
if 'p' not in param:
return
page_group = param['p'][0]
if page_group in connections:
connections[page_group].add(request)
else:
connections[page_group] = set([request])
message = None
dataToBroadcast = {}
try:
message = msgutil.receive_message(request)
# notify to client that message is received by server.
msgutil.send_message(request, message)
msgutil.receive_message(request)
dataToBroadcast['message'] = message
dataToBroadcast['closeCode'] = str(request.ws_close_code)
finally:
# request is closed. notify this dataToBroadcast to other WebSockets.
connections[page_group].remove(request)
for ws in connections[page_group]:
msgutil.send_message(ws, json.dumps(dataToBroadcast))
def onMessage(self, mosq, obj, msg):
if _status_ == _OPEN_:
try:
string = json.dumps({"topic": msg.topic, "message": msg.payload})
msgutil.send_message(self.socket, string)
except Exception:
return
def onPublish(self, mosq, obj, mid):
if _status_ == _OPEN_:
try:
string = json.dumps({"topic": self.topic + "/server", "message": "Message published to broker"})
msgutil.send_message(self.socket, string)
except Exception:
return
def web_socket_transfer_data(request):
# pywebsocket does not mask message by default. We need to build a frame manually to mask it.
request.connection.write(stream.create_text_frame('First message', mask=False))
request.connection.write(stream.create_text_frame('Fragmented ', opcode=common.OPCODE_TEXT, fin=0, mask=False))
request.connection.write(stream.create_text_frame('message', opcode=common.OPCODE_CONTINUATION, fin=1, mask=False))
request.connection.write(stream.create_text_frame('', mask=False))
msgutil.send_message(request, 'END')
# Wait for the client to start closing handshake.
# To receive a close frame, we must use an internal method of request.ws_stream.
opcode, payload, final, reserved1, reserved2, reserved3 = request.ws_stream._receive_frame()
assert opcode == common.OPCODE_CLOSE
assert final
assert not reserved1
assert not reserved2
assert not reserved3
# Send a masked close frame. Clients should be able to handle this frame and
# the WebSocket object should be closed cleanly.
request.connection.write(stream.create_close_frame('', mask=False))
# Prevents pywebsocket from starting its own closing handshake.
raise handshake.AbortedByUserException('Abort the connection')
def web_socket_transfer_data(request):
from urlparse import urlparse
from urlparse import parse_qs
#requests.append(request)
url = urlparse(request.get_uri())
query = parse_qs(url.query)
if query.has_key('projectName'):
projectNames = query["projectName"]
if len(projectNames) == 1:
projectName = projectNames[0]
if not rooms.has_key(projectName):
rooms[projectName] = []
rooms[projectName].append(request)
while True:
try:
message = msgutil.receive_message(request)
except Exception:
return
#for req in requests:
# try:
# msgutil.send_message(req, message)
# except Exception:
# requests.remove(req)
for req in rooms[projectName]:
try:
msgutil.send_message(req, message)
except Exception:
rooms[projectName].remove(req)
if len(rooms[projectName]) == 0:
del rooms[projectName]
def web_socket_transfer_data(request):
while True:
line = request.ws_stream.receive_message()
if line == "echo":
query = request.unparsed_uri.split('?')[1]
GET = dict(urllib.parse.parse_qsl(query))
# TODO(kristijanburnik): This code should be reused from
# /mixed-content/generic/expect.py or implemented more generally
# for other tests.
path = GET.get("path", request.unparsed_uri.split('?')[0])
key = GET["key"]
action = GET["action"]
if action == "put":
value = GET["value"]
stash.take(key=key, path=path)
stash.put(key=key, value=value, path=path)
response_data = json.dumps({"status": "success", "result": key})
elif action == "purge":
value = stash.take(key=key, path=path)
response_data = json.dumps({"status": "success", "result": value})
elif action == "take":
value = stash.take(key=key, path=path)
if value is None:
status = "allowed"
else:
status = "blocked"
response_data = json.dumps({"status": status, "result": value})
msgutil.send_message(request, response_data)
return
def web_socket_transfer_data(request):
for i in range(1, 128):
request.connection.write(chr(i) + str(i) + '\xff')
for i in range(128, 256):
msg = str(i)
request.connection.write(chr(i) + chr(len(msg)) + msg)
msgutil.send_message(request, 'done')
def test_send_message_deflate_frame(self):
compress = zlib.compressobj(
zlib.Z_DEFAULT_COMPRESSION, zlib.DEFLATED, -zlib.MAX_WBITS)
extension = common.ExtensionParameter(common.DEFLATE_FRAME_EXTENSION)
request = _create_request_from_rawdata(
'', deflate_frame_request=extension)
msgutil.send_message(request, 'Hello')
msgutil.send_message(request, 'World')
expected = ''
compressed_hello = compress.compress('Hello')
compressed_hello += compress.flush(zlib.Z_SYNC_FLUSH)
compressed_hello = compressed_hello[:-4]
expected += '\xc1%c' % len(compressed_hello)
expected += compressed_hello
compressed_world = compress.compress('World')
compressed_world += compress.flush(zlib.Z_SYNC_FLUSH)
compressed_world = compressed_world[:-4]
expected += '\xc1%c' % len(compressed_world)
expected += compressed_world
self.assertEqual(expected, request.connection.written_data())
def web_socket_transfer_data(request):
pragma = request.headers_in.get('Pragma')
cache_control = request.headers_in.get('Cache-Control')
if pragma == 'no-cache' and cache_control == 'no-cache':
msgutil.send_message(request, 'PASS')
else:
msgutil.send_message(request, 'FAIL')
def listen_psirp_updates(request, subscriber):
while True:
for version in subscriber.listen():
if version is not None: # if publication exists
print('Sending from Blackhawk: %s' % str(version.buffer))
msgutil.send_message(request, '%s' % str(version.buffer))
else:
print("Received Publishment was null :(")
def test_send_message_deflate_stream(self):
compress = zlib.compressobj(zlib.Z_DEFAULT_COMPRESSION, zlib.DEFLATED, -zlib.MAX_WBITS)
request = _create_request_from_rawdata("", deflate_stream=True)
msgutil.send_message(request, "Hello")
expected = compress.compress("\x81\x05Hello")
expected += compress.flush(zlib.Z_SYNC_FLUSH)
self.assertEqual(expected, request.connection.written_data())
def web_socket_transfer_data(request):
while True:
rcvd = msgutil.receive_message(request)
opcode = request.ws_stream.get_last_received_opcode()
if (opcode == common.OPCODE_BINARY):
msgutil.send_message(request, rcvd, binary=True)
elif (opcode == common.OPCODE_TEXT):
msgutil.send_message(request, rcvd)
def web_socket_transfer_data(request): while True: s = msgutil.receive_message(request) for connect in arr: try: msgutil.send_message(connect, s) except: arr.remove(connect)
def web_socket_transfer_data(request):
while True:
line = msgutil.receive_message(request)
print "received:", line
line = str(int(line)*2)
msgutil.send_message(request, line)
if line == _GOODBYE_MESSAGE:
return
def web_socket_transfer_data(request):
# send_message's third argument corresponds to "fin" bit;
# it is set to True if this frame is the final fragment of a message.
pause_briefly()
msgutil.send_message(request, '', False)
pause_briefly()
msgutil.send_message(request, '', True)
pause_briefly()
def web_socket_transfer_data(request):
expected_messages = ['Hello, world!']
for test_number, expected_message in enumerate(expected_messages):
frame = _retrieve_frame(request.ws_stream)
if frame.opcode == common.OPCODE_BINARY and frame.payload == expected_message and frame.fin:
msgutil.send_message(request, 'PASS: Message #%d.' % test_number)
else:
msgutil.send_message(request, 'FAIL: Message #%d: Received unexpected frame: opcode = %r, payload = %r, final = %r' % (test_number, frame.opcode, frame.payload, frame.fin))
def web_socket_transfer_data(request): while True: s = msgutil.receive_message(request) n = int(s) total = 0 for i in range(1,n + 1): total = total + i s2 = str(total) msgutil.send_message(request, s2)
def test_send_message(self):
request = _create_request()
msgutil.send_message(request, "Hello")
self.assertEqual("\x81\x05Hello", request.connection.written_data())
payload = "a" * 125
request = _create_request()
msgutil.send_message(request, payload)
self.assertEqual("\x81\x7d" + payload, request.connection.written_data())
def web_socket_transfer_data(request):
expected_messages = ['Hello, world!', '', all_distinct_bytes()]
for test_number, expected_message in enumerate(expected_messages):
message = msgutil.receive_message(request)
if type(message) == str and message == expected_message:
msgutil.send_message(request, 'PASS: Message #%d.' % test_number)
else:
msgutil.send_message(request, 'FAIL: Message #%d: Received unexpected message: %r' % (test_number, message))
def web_socket_transfer_data(request):
match = re.search(r"\?opcode=(\d+)$", request.ws_resource)
if match is None:
msgutil.send_message(request, "FAIL: Query value is incorrect or missing")
return
opcode = int(match.group(1))
payload = "This text should be ignored. (opcode = %d)" % opcode
request.connection.write(stream.create_header(opcode, len(payload), 1, 0, 0, 0, 0) + payload)
def initialize_subscriber(request):
line = msgutil.receive_message(request).encode('utf-8')
try:
msg = json.loads(line)
sid = str(msg["subscribe"]["sid"])
rid = str(msg["subscribe"]["rid"])
except ValueError, e:
msgutil.send_message(request, '%s' % json_message("message", str(e) + " " + line))
return False
def test_send_medium_message(self):
payload = "a" * 126
request = _create_request()
msgutil.send_message(request, payload)
self.assertEqual("\x81\x7e\x00\x7e" + payload, request.connection.written_data())
payload = "a" * ((1 << 16) - 1)
request = _create_request()
msgutil.send_message(request, payload)
self.assertEqual("\x81\x7e\xff\xff" + payload, request.connection.written_data())
def web_socket_transfer_data(request):
expected_messages = ['Hello, world!']
for test_number, expected_message in enumerate(expected_messages):
# FIXME: Use better API.
opcode, payload, final, unused_reserved1, unused_reserved2, unused_reserved3 = request.ws_stream._receive_frame()
if opcode == common.OPCODE_BINARY and payload == expected_message and final:
msgutil.send_message(request, 'PASS: Message #%d.' % test_number)
else:
msgutil.send_message(request, 'FAIL: Message #%d: Received unexpected frame: opcode = %r, payload = %r, final = %r' % (test_number, opcode, payload, final))
def web_socket_transfer_data(request):
while True:
time.sleep(1)
try:
line = msgutil.receive_message(request)
except Exception, e:
raise e
msgutil.send_message(request, line)
if line == GOODBYEMESSAGE:
return
def test_send_message(self):
request = _create_request()
msgutil.send_message(request, 'Hello')
self.assertEqual('\x81\x05Hello', request.connection.written_data())
payload = 'a' * 125
request = _create_request()
msgutil.send_message(request, payload)
self.assertEqual('\x81\x7d' + payload,
request.connection.written_data())
def run(self):
while True:
line = msgutil.receive_message(self.websocket).encode('utf-8')
print("received %s" % line)
try:
msg = json.loads(line)
self.act_on(msg)
continue
except ValueError, e:
msg = json_message("message", "data is not json: "+ line)
msgutil.send_message(self.websocket, '%s' % msg)
def web_socket_transfer_data(request):
subscriber = initialize_subscriber(request)
initial_content = subscriber.get_initial_content()
if initial_content is not None:
print("Sending initial content: %s" % str(initial_content.buffer))
msgutil.send_message(request, '%s' % str(initial_content.buffer))
seat_reserver = SeatReserver(request, subscriber.sid, subscriber.rid)
seat_reserver.start()
listen_psirp_updates(request, subscriber)
def web_socket_transfer_data(request):
global connections
connections[request] = True
socketName = None
try:
socketName = msgutil.receive_message(request)
# notify to client that socketName is received by server.
msgutil.send_message(request, socketName)
msgutil.receive_message(request) # wait, and exception by close.
socketName = socketName + ': receive next message'
finally:
# request is closed. notify this socketName to other web sockets.
del connections[request]
for ws in connections.keys():
msgutil.send_message(ws, socketName)
def web_socket_transfer_data(request):
expected_messages = ["Hello, world!", "", all_distinct_bytes()]
for test_number, expected_message in enumerate(expected_messages):
expected_message = six.b(expected_message)
message = msgutil.receive_message(request)
if message == expected_message:
msgutil.send_message(request, "PASS: Message #{:d}.".format(test_number))
else:
msgutil.send_message(
request,
"FAIL: Message #{:d}: Received unexpected message: {!r}".format(
test_number, message
),
)
def test_send_message_fragments(self):
request = _create_request()
msgutil.send_message(request, 'Hello', False)
msgutil.send_message(request, ' ', False)
msgutil.send_message(request, 'World', False)
msgutil.send_message(request, '!', True)
self.assertEqual(b'\x01\x05Hello\x00\x01 \x00\x05World\x80\x01!',
request.connection.written_data())
def test_send_message(self):
extension = common.ExtensionParameter(
common.PERMESSAGE_DEFLATE_EXTENSION)
request = _create_request_from_rawdata(
b'', permessage_deflate_request=extension)
msgutil.send_message(request, 'Hello')
compress = zlib.compressobj(zlib.Z_DEFAULT_COMPRESSION, zlib.DEFLATED,
-zlib.MAX_WBITS)
compressed_hello = compress.compress(b'Hello')
compressed_hello += compress.flush(zlib.Z_SYNC_FLUSH)
compressed_hello = compressed_hello[:-4]
expected = b'\xc1%c' % len(compressed_hello)
expected += compressed_hello
self.assertEqual(expected, request.connection.written_data())
def web_socket_transfer_data(request):
# Wait for a close frame sent from the client.
close_frame = request.ws_stream.receive_bytes(2)
# Tell the client what we have received.
msgutil.send_message(request, 'close_frame=%r' % close_frame)
# If the following assertion fails, AssertionError will be raised,
# which will prevent pywebsocket from sending a close frame.
# In this case, the client will fail to finish closing handshake, thus
# closeEvent.wasClean will become false.
assert close_frame == '\xff\x00'
# Pretend we have received a close frame from the client.
# After this function exits, pywebsocket will send a close frame automatically.
request.client_terminated = True
def test_send_empty_message(self):
"""Test that an empty message is compressed correctly."""
extension = common.ExtensionParameter(
common.PERMESSAGE_DEFLATE_EXTENSION)
request = _create_request_from_rawdata(
b'', permessage_deflate_request=extension)
msgutil.send_message(request, '')
# Payload in binary: 0b00000000
# From LSB,
# - 1 bit of BFINAL (0)
# - 2 bits of BTYPE (no compression)
# - 5 bits of padding
self.assertEqual(b'\xc1\x01\x00', request.connection.written_data())
def web_socket_transfer_data(request):
# Wait for a close frame sent from the client.
close_frame = request.ws_stream.receive_bytes(6)
# Send only first two bytes of the received frame. The remaining four bytes are
# "masking key", which changes every time the test runs.
msgutil.send_message(request, 'close_frame[:2]=%r' % close_frame[:2])
# If the following assertion fails, AssertionError will be raised,
# which will prevent pywebsocket from sending a close frame.
# In this case, the client will fail to finish closing handshake, thus
# closeEvent.wasClean will become false.
assert close_frame[:2] == '\x88\x80'
# Pretend we have received a close frame from the client.
# After this function exits, pywebsocket will send a close frame automatically.
request.client_terminated = True
def web_socket_transfer_data(request):
global connections
connections[request] = True
socketName = None
receivedException = True
try:
socketName = msgutil.receive_message(request)
msgutil.send_message(request, socketName)
msgutil.receive_message(request) # wait, and exception by close.
receivedException = False
finally:
# We keep track of whether we have an exception.
del connections[request]
for ws in connections.keys():
msgutil.send_message(
ws, "Closed by exception"
if receivedException else "Closed without exception")
def web_socket_transfer_data(request):
# Wait for a close frame sent from the client.
close_frame = request.ws_stream.receive_bytes(6)
msgutil.send_message(request, 'Client should ignore this message')
# Send only first two bytes of the received frame. The remaining four bytes
# are "masking key", which changes every time the test runs.
message = "close_frame[:2]='%s'" % util.hexify(close_frame[:2])
data = struct.pack('!H', 1000) + message.encode('UTF-8')
request.connection.write(stream.create_close_frame(data))
# Tell pywebsocket we have sent a close frame to the client, so it can close
# the connection.
request.server_terminated = True
def web_socket_transfer_data(request):
send_payload = ''
r = request.ws_resource.split('?', 1)
if len(r) == 2:
params = cgi.parse_qs(r[1])
if 'payload' in params:
send_payload = params['payload'][0]
msgutil.send_ping(request, send_payload)
# We need to use an internal function to detect a pong frame from the client.
opcode, recv_payload, final, reserved1, reserved2, reserved3 = request.ws_stream._receive_frame()
if opcode == common.OPCODE_PONG and recv_payload == send_payload and final and not reserved1 and not reserved2 and not reserved3:
msgutil.send_message(request, 'PASS')
else:
msgutil.send_message(request,
'FAIL: Received unexpected frame: opcode = %r, payload = %r, final = %r, reserved1 = %r, reserved2 = %r, reserved3 = %r' %
(opcode, recv_payload, final, reserved1, reserved2, reserved3))
def web_socket_transfer_data(request):
line = request.ws_stream.receive_message()
query = json.loads(line)
action = query["action"]
key = query["key"]
if action == "set":
value = query["value"]
handle_set(key, value)
response = {}
elif action == "get":
value = handle_get(key)
response = {"value": value}
else:
response = {}
msgutil.send_message(request, json.dumps(response))
def test_send_message_deflate_frame_no_context_takeover_parameter(self):
compress = zlib.compressobj(zlib.Z_DEFAULT_COMPRESSION, zlib.DEFLATED,
-zlib.MAX_WBITS)
extension = common.ExtensionParameter(common.DEFLATE_FRAME_EXTENSION)
extension.add_parameter('no_context_takeover', None)
request = _create_request_from_rawdata('',
deflate_frame_request=extension)
for i in xrange(3):
msgutil.send_message(request, 'Hello')
compressed_message = compress.compress('Hello')
compressed_message += compress.flush(zlib.Z_SYNC_FLUSH)
compressed_message = compressed_message[:-4]
expected = '\xc1%c' % len(compressed_message)
expected += compressed_message
self.assertEqual(expected + expected + expected,
request.connection.written_data())
def web_socket_transfer_data(request):
# Wait for a close frame sent from the client.
close_frame = request.ws_stream.receive_bytes(6)
msgutil.send_message(request, 'Client should ignore this message')
# Send only first two bytes of the received frame. The remaining four bytes are
# "masking key", which changes every time the test runs.
data = struct.pack('!H', 1000) + ('close_frame[:2]={}'.format(
close_frame[:2]).replace("='", "=b'")).encode()
request.connection.write(stream.create_close_frame(data))
# If the following assertion fails, AssertionError will be raised,
# which will prevent pywebsocket from sending a close frame.
# In this case, the client will fail to finish closing handshake, thus
# closeEvent.wasClean will become false.
assert close_frame[:2] == b'\x88\x80'
# Pretend we have received a close frame from the client.
# After this function exits, pywebsocket will send a close frame automatically.
request.client_terminated = True
def test_send_message_deflate_frame_comp_bit(self):
compress = zlib.compressobj(zlib.Z_DEFAULT_COMPRESSION, zlib.DEFLATED,
-zlib.MAX_WBITS)
extension = common.ExtensionParameter(common.DEFLATE_FRAME_EXTENSION)
request = _create_request_from_rawdata('',
deflate_frame_request=extension)
self.assertEquals(1, len(request.ws_extension_processors))
deflate_frame_processor = request.ws_extension_processors[0]
msgutil.send_message(request, 'Hello')
deflate_frame_processor.disable_outgoing_compression()
msgutil.send_message(request, 'Hello')
deflate_frame_processor.enable_outgoing_compression()
msgutil.send_message(request, 'Hello')
expected = ''
compressed_hello = compress.compress('Hello')
compressed_hello += compress.flush(zlib.Z_SYNC_FLUSH)
compressed_hello = compressed_hello[:-4]
expected += '\xc1%c' % len(compressed_hello)
expected += compressed_hello
expected += '\x81\x05Hello'
compressed_2nd_hello = compress.compress('Hello')
compressed_2nd_hello += compress.flush(zlib.Z_SYNC_FLUSH)
compressed_2nd_hello = compressed_2nd_hello[:-4]
expected += '\xc1%c' % len(compressed_2nd_hello)
expected += compressed_2nd_hello
self.assertEqual(expected, request.connection.written_data())
def test_send_message_fragmented(self):
extension = common.ExtensionParameter(
common.PERMESSAGE_DEFLATE_EXTENSION)
request = _create_request_from_rawdata(
b'', permessage_deflate_request=extension)
msgutil.send_message(request, 'Hello', end=False)
msgutil.send_message(request, 'Goodbye', end=False)
msgutil.send_message(request, 'World')
compress = zlib.compressobj(zlib.Z_DEFAULT_COMPRESSION, zlib.DEFLATED,
-zlib.MAX_WBITS)
compressed_hello = compress.compress(b'Hello')
compressed_hello += compress.flush(zlib.Z_SYNC_FLUSH)
expected = b'\x41%c' % len(compressed_hello)
expected += compressed_hello
compressed_goodbye = compress.compress(b'Goodbye')
compressed_goodbye += compress.flush(zlib.Z_SYNC_FLUSH)
expected += b'\x00%c' % len(compressed_goodbye)
expected += compressed_goodbye
compressed_world = compress.compress(b'World')
compressed_world += compress.flush(zlib.Z_SYNC_FLUSH)
compressed_world = compressed_world[:-4]
expected += b'\x80%c' % len(compressed_world)
expected += compressed_world
self.assertEqual(expected, request.connection.written_data())
def web_socket_transfer_data(request):
while True:
line = request.ws_stream.receive_message()
if line == "echo":
query = request.unparsed_uri.split('?')[1]
GET = dict(urlparse.parse_qsl(query))
# TODO(kristijanburnik): This code should be reused from
# /mixed-content/generic/expect.py or implemented more generally
# for other tests.
path = GET.get("path", request.unparsed_uri.split('?')[0])
key = GET["key"]
action = GET["action"]
if action == "put":
value = GET["value"]
stash.take(key=key, path=path)
stash.put(key=key, value=value, path=path)
response_data = json.dumps({
"status": "success",
"result": key
})
elif action == "purge":
value = stash.take(key=key, path=path)
response_data = json.dumps({
"status": "success",
"result": value
})
elif action == "take":
value = stash.take(key=key, path=path)
if value is None:
status = "allowed"
else:
status = "blocked"
response_data = json.dumps({"status": status, "result": value})
msgutil.send_message(request, response_data)
return
def test_send_message_with_null_character(self):
"""Test that a simple payload (one null) is framed correctly."""
extension = common.ExtensionParameter(
common.PERMESSAGE_DEFLATE_EXTENSION)
request = _create_request_from_rawdata(
b'', permessage_deflate_request=extension)
msgutil.send_message(request, '\x00')
# Payload in binary: 0b01100010 0b00000000 0b00000000
# From LSB,
# - 1 bit of BFINAL (0)
# - 2 bits of BTYPE (01 that means fixed Huffman)
# - 8 bits of the first code (00110000 that is the code for the literal
# alphabet 0x00)
# - 7 bits of the second code (0000000 that is the code for the
# end-of-block)
# - 1 bit of BFINAL (0)
# - 2 bits of BTYPE (no compression)
# - 2 bits of padding
self.assertEqual(b'\xc1\x03\x62\x00\x00',
request.connection.written_data())
def read(self):
try:
length = 0
f = open(self.filename, 'r')
for line in f:
length += 1
f.seek(0)
cnt = 0
for line in f:
cnt += 1
if cnt == length:
#######################################################
# Note::
# mesgutil.send_message()'s second parameter require
# 'unicode'. so you shoule use decode('utf-8')
#######################################################
msgutil.send_message(self.sock, line[:-1].decode('utf-8'))
f.close
except Exception:
if(f):
f.close
def web_socket_transfer_data(request):
# pywebsocket does not mask message by default. We need to build a frame manually to mask it.
request.connection.write(
stream.create_text_frame('First message', mask=True))
request.connection.write(
stream.create_text_frame('Fragmented ',
opcode=common.OPCODE_TEXT,
fin=0,
mask=True))
request.connection.write(
stream.create_text_frame('message',
opcode=common.OPCODE_CONTINUATION,
fin=1,
mask=True))
request.connection.write(stream.create_text_frame('', mask=True))
msgutil.send_message(request, 'END')
# Wait for the client to start closing handshake.
# To receive a close frame, we must use an internal method of request.ws_stream.
opcode, payload, final, reserved1, reserved2, reserved3 = request.ws_stream._receive_frame(
)
assert opcode == common.OPCODE_CLOSE
assert final
assert not reserved1
assert not reserved2
assert not reserved3
# Send a masked close frame. Clients should be able to handle this frame and
# the WebSocket object should be closed cleanly.
request.connection.write(stream.create_close_frame('', mask=True))
raise handshake.AbortedByUserException(
'Abort the connection'
) # Prevents pywebsocket from starting its own closing handshake.
def web_socket_transfer_data(request):
# Send three messages, and then wait for three messages.
msgutil.send_message(request, '1')
msgutil.send_message(request, '2')
msgutil.send_message(request, '3')
for expected in (u'1', u'2', u'3'):
message = msgutil.receive_message(request)
if type(message) != str or message != expected:
raise handshake.AbortedByUserException('Abort the connection')
def web_socket_transfer_data(request):
while True:
line = msgutil.receive_message(request)
if line == 'protocol':
msgutil.send_message(request, request.ws_protocol)
continue
if line == 'resource':
msgutil.send_message(request, request.ws_resource)
continue
if line == 'origin':
msgutil.send_message(request, request.ws_origin)
continue
msgutil.send_message(request, line)
if line == 'end':
return
def web_socket_transfer_data(request):
while True:
line = msgutil.receive_message(request)
if line == "protocol":
msgutil.send_message(request, request.ws_protocol)
continue
if line == "resource":
msgutil.send_message(request, request.ws_resource)
continue
if line == "origin":
msgutil.send_message(request, request.ws_origin)
continue
msgutil.send_message(request, line)
if line == "end":
return
def web_socket_transfer_data(request):
#function is called when a websocket connection is established
sp = sphero.Sphero()
print "Connected to Web-Client"
while True:
try:
data = json.loads(msgutil.receive_message(
request)) #read websocket and deserialize the JSON object
command = data["command"]
listDevicesThread = None
connectionThread = None
if (command == "listDevices"):
print 'list spheros'
devices = sp.findSpheros()
jDev = []
for d in devices:
jDev.append({'name': d[1], 'address': d[0]})
print "found: ", jDev
if len(jDev) == 0:
print "Pair Sphero to computer via Bluetooth Manager first."
print "Then, try to select address again."
msgutil.send_message(request, json.dumps(
jDev)) #serialize list into JSON and send over the socket
elif (command == "cancelListDevices"):
print "cancel device search"
listDevicesThread.terminate()
listDevicesThread = None
elif (command == "connectToDevice"):
name = data["name"]
address = data["address"]
print "connect to: ", name, address
try:
sp.connect(address)
msgutil.send_message(request,
json.dumps({'connected': True}))
print "connection successful"
except Exception, e:
print str(e)
msgutil.send_message(request,
json.dumps({'connected': False}))
print "connection failed"
elif (command == "cancelConnection"):
print "cancel attempted connection"
connectionThread.terminate()
connectionThread = None
elif (command == "disconnect"):
try:
sp.disconnect()
except:
pass
def web_socket_transfer_data(request):
for i in range(NUMBER_OF_MESSAGES):
# We need to use an internal function to verify that the frame has the
# "final" flag set.
opcode, recv_payload, final, reserved1, reserved2, reserved3 = \
request.ws_stream._receive_frame()
# We assume that the browser will not send any control messages.
if opcode != common.OPCODE_BINARY:
msgutil.send_message(request,
'FAIL: message %r was not opcode binary' % i)
return
if not final:
msgutil.send_message(request,
'FAIL: message %r was fragmented' % i)
return
msgutil.send_message(request, 'OK: message %r not fragmented' % i)
def web_socket_transfer_data(request):
while True:
line = msgutil.receive_message(request)
msgutil.send_message(request, line)
if line == _GOODBYE_MESSAGE:
return
def web_socket_transfer_data(request):
msgutil.send_message(request, 'Hello from Simple WSH.')
def web_socket_transfer_data(request):
msgutil.send_message(request, request.ws_protocol)
# Wait for a close message.
unused = request.ws_stream.receive_message()
def send(self, req, obj):
return send_message(req, dumps(obj))
def send_result(self, req, code, result):
return send_message(req, dumps([code, result]))
def web_socket_transfer_data(request):
msgutil.send_message(request, 'Hello from Handshake Error WSH.')
