def _create_request_from_rawdata(
read_data, deflate_stream=False, deflate_frame_request=None):
req = mock.MockRequest(connection=mock.MockConn(''.join(read_data)))
req.ws_version = common.VERSION_HYBI_LATEST
stream_options = StreamOptions()
stream_options.deflate_stream = deflate_stream
req.ws_extension_processors = []
if deflate_frame_request is not None:
processor = DeflateFrameExtensionProcessor(deflate_frame_request)
response = processor.get_extension_response()
if response is not None:
processor.setup_stream_options(stream_options)
req.ws_extension_processors.append(processor)
req.ws_stream = Stream(req, stream_options)
return req
def connect(self):
self._socket = socket.socket()
self._socket.settimeout(int(self.dictionary.get('socket_timeout')))
try:
self._socket.connect((self.dictionary.get('server_host'),
int(self.dictionary.get('server_port'))))
if self.dictionary.get('use_tls') == 'True':
self._socket = _TLSSocket(self._socket)
version = self.dictionary.get('protocol_version')
self._handshake = ClientHandshakeProcessor(
self._socket, self.dictionary)
self._handshake.handshake()
self._logger.info('Connection established')
request = ClientRequest(self._socket)
version_map = {
_PROTOCOL_VERSION_HYBI13: common.VERSION_HYBI13}
request.ws_version = version_map[version]
stream_option = StreamOptions()
stream_option.mask_send = True
stream_option.unmask_receive = False
if self.dictionary.get('deflate_stream') == 'True':
stream_option.deflate_stream = True
if self.dictionary.get('deflate_frame') == 'True':
processor = True
processor.setup_stream_options(stream_option)
self._stream = Stream(request, stream_option)
listen = ListenSocket(self, self.received)
write = WriteSocket(self, self.toSend)
listen.start()
write.start()
finally:
print "po powitaniu, serwer oczekuje na dane"
def _create_request_from_rawdata(
read_data, deflate_stream=False, deflate_frame_request=None,
perframe_compression_request=None, permessage_compression_request=None):
req = mock.MockRequest(connection=mock.MockConn(''.join(read_data)))
req.ws_version = common.VERSION_HYBI_LATEST
stream_options = StreamOptions()
stream_options.deflate_stream = deflate_stream
req.ws_extension_processors = []
if deflate_frame_request is not None:
processor = DeflateFrameExtensionProcessor(deflate_frame_request)
_install_extension_processor(processor, req, stream_options)
elif perframe_compression_request is not None:
processor = PerFrameCompressionExtensionProcessor(
perframe_compression_request)
_install_extension_processor(processor, req, stream_options)
elif permessage_compression_request is not None:
processor = PerMessageCompressionExtensionProcessor(
permessage_compression_request)
_install_extension_processor(processor, req, stream_options)
req.ws_stream = Stream(req, stream_options)
return req
def _create_request_from_rawdata(read_data,
deflate_stream=False,
deflate_frame_request=None,
perframe_compression_request=None,
permessage_compression_request=None):
req = mock.MockRequest(connection=mock.MockConn(''.join(read_data)))
req.ws_version = common.VERSION_HYBI_LATEST
stream_options = StreamOptions()
stream_options.deflate_stream = deflate_stream
req.ws_extension_processors = []
if deflate_frame_request is not None:
processor = DeflateFrameExtensionProcessor(deflate_frame_request)
_install_extension_processor(processor, req, stream_options)
elif perframe_compression_request is not None:
processor = PerFrameCompressionExtensionProcessor(
perframe_compression_request)
_install_extension_processor(processor, req, stream_options)
elif permessage_compression_request is not None:
processor = PerMessageCompressionExtensionProcessor(
permessage_compression_request)
_install_extension_processor(processor, req, stream_options)
req.ws_stream = Stream(req, stream_options)
return req
def run(self):
"""Run the client.
Shake hands and then repeat sending message and receiving its echo.
"""
self._socket = socket.socket()
self._socket.settimeout(self._options.socket_timeout)
try:
self._socket.connect(
(self._options.server_host, self._options.server_port))
if self._options.use_tls:
self._socket = _TLSSocket(
self._socket, self._options.tls_module,
self._options.tls_version,
self._options.disable_tls_compression)
version = self._options.protocol_version
if (version == _PROTOCOL_VERSION_HYBI08
or version == _PROTOCOL_VERSION_HYBI13):
self._handshake = ClientHandshakeProcessor(
self._socket, self._options)
elif version == _PROTOCOL_VERSION_HYBI00:
self._handshake = ClientHandshakeProcessorHybi00(
self._socket, self._options)
else:
raise ValueError('Invalid --protocol-version flag: %r' %
version)
self._handshake.handshake()
self._logger.info('Connection established')
request = ClientRequest(self._socket)
version_map = {
_PROTOCOL_VERSION_HYBI08: common.VERSION_HYBI08,
_PROTOCOL_VERSION_HYBI13: common.VERSION_HYBI13,
_PROTOCOL_VERSION_HYBI00: common.VERSION_HYBI00
}
request.ws_version = version_map[version]
if (version == _PROTOCOL_VERSION_HYBI08
or version == _PROTOCOL_VERSION_HYBI13):
stream_option = StreamOptions()
stream_option.mask_send = True
stream_option.unmask_receive = False
if self._options.deflate_stream:
stream_option.deflate_stream = True
if self._options.deflate_frame is not False:
processor = self._options.deflate_frame
processor.setup_stream_options(stream_option)
self._stream = Stream(request, stream_option)
elif version == _PROTOCOL_VERSION_HYBI00:
self._stream = StreamHixie75(request, True)
for line in self._options.message.split(','):
self._stream.send_message(line)
if self._options.verbose:
print 'Send: %s' % line
try:
received = self._stream.receive_message()
if self._options.verbose:
print 'Recv: %s' % received
except Exception, e:
if self._options.verbose:
print 'Error: %s' % e
raise
self._do_closing_handshake()
def run(self):
"""Run the client.
Shake hands and then repeat sending message and receiving its echo.
"""
self._socket = socket.socket()
self._socket.settimeout(self._options.socket_timeout)
try:
self._socket.connect((self._options.server_host,
self._options.server_port))
if self._options.use_tls:
self._socket = _TLSSocket(
self._socket,
self._options.tls_module,
self._options.tls_version,
self._options.disable_tls_compression)
version = self._options.protocol_version
if (version == _PROTOCOL_VERSION_HYBI08 or
version == _PROTOCOL_VERSION_HYBI13):
self._handshake = ClientHandshakeProcessor(
self._socket, self._options)
elif version == _PROTOCOL_VERSION_HYBI00:
self._handshake = ClientHandshakeProcessorHybi00(
self._socket, self._options)
else:
raise ValueError(
'Invalid --protocol-version flag: %r' % version)
self._handshake.handshake()
self._logger.info('Connection established')
request = ClientRequest(self._socket)
version_map = {
_PROTOCOL_VERSION_HYBI08: common.VERSION_HYBI08,
_PROTOCOL_VERSION_HYBI13: common.VERSION_HYBI13,
_PROTOCOL_VERSION_HYBI00: common.VERSION_HYBI00}
request.ws_version = version_map[version]
if (version == _PROTOCOL_VERSION_HYBI08 or
version == _PROTOCOL_VERSION_HYBI13):
stream_option = StreamOptions()
stream_option.mask_send = True
stream_option.unmask_receive = False
if self._options.deflate_stream:
stream_option.deflate_stream = True
if self._options.deflate_frame is not False:
processor = self._options.deflate_frame
processor.setup_stream_options(stream_option)
self._stream = Stream(request, stream_option)
elif version == _PROTOCOL_VERSION_HYBI00:
self._stream = StreamHixie75(request, True)
for line in self._options.message.split(','):
self._stream.send_message(line)
if self._options.verbose:
print 'Send: %s' % line
try:
received = self._stream.receive_message()
if self._options.verbose:
print 'Recv: %s' % received
except Exception, e:
if self._options.verbose:
print 'Error: %s' % e
raise
self._do_closing_handshake()
