def __init__(
self, sock, io_loop, use_ssl,
certfile, keyfile, ca_certs, cert_reqs):
self.use_ssl = use_ssl
self.timeout = None
if self.use_ssl:
# In Python 3, Tornado's ssl_options_to_context fails if
# any options are None.
ssl_options = {}
if certfile:
ssl_options['certfile'] = certfile
if keyfile:
ssl_options['keyfile'] = keyfile
if ca_certs:
ssl_options['ca_certs'] = ca_certs
if cert_reqs:
ssl_options['cert_reqs'] = cert_reqs
self.stream = iostream.SSLIOStream(
sock, ssl_options=ssl_options, io_loop=io_loop)
else:
self.stream = iostream.IOStream(sock, io_loop=io_loop)
def __init__(self, url, protocols=None, extensions=None,
io_loop=None, ssl_options=None, headers=None):
"""
.. code-block:: python
from tornado import ioloop
class MyClient(TornadoWebSocketClient):
def opened(self):
for i in range(0, 200, 25):
self.send("*" * i)
def received_message(self, m):
print((m, len(str(m))))
def closed(self, code, reason=None):
ioloop.IOLoop.instance().stop()
ws = MyClient('ws://localhost:9000/echo', protocols=['http-only', 'chat'])
ws.connect()
ioloop.IOLoop.instance().start()
"""
WebSocketBaseClient.__init__(self, url, protocols, extensions,
ssl_options=ssl_options, headers=headers)
self.ssl_options["do_handshake_on_connect"] = False
if self.scheme == "wss":
self.sock = ssl.wrap_socket(self.sock, **self.ssl_options)
self.io = iostream.SSLIOStream(self.sock, io_loop)
else:
self.io = iostream.IOStream(self.sock, io_loop)
self.io_loop = io_loop
def _get_ssl_socket(self, stream, **kwargs):
# This makes it simpler for SMTP_SSL to use the SMTP connect code
# and just alter the socket connection bit.
callback = kwargs.pop('callback')
if hasattr(self, '__get_ssl_socket'):
callback(self.__get_ssl_socket)
return
if PY3:
# due to ssl wrap_socket will detach argument sock in Python 3 and
# can't be used no longer.Also the behaviour of socket.socket.close
# is different between 2 and 3.
sock = stream.socket
iden_sock = socket.fromfd(sock.fileno(), sock.family, sock.type)
ssl_sock = ssl.wrap_socket(iden_sock,
do_handshake_on_connect=False,
**kwargs)
stream.close()
else:
ssl_sock = ssl.wrap_socket(stream.socket,
do_handshake_on_connect=False,
**kwargs)
stream.close()
stream = iostream.SSLIOStream(ssl_sock)
self.__get_ssl_socket = stream
callback(stream)
def connect(self):
""" Setup socket """
self.sock = socket(AF_INET, SOCK_STREAM)
self.remote_stream = iostream.SSLIOStream(self.sock, ssl_options=dict(certfile=self.certfile, keyfile=self.keyfile))
self.remote_stream.connect(self.host, self._on_feedback_service_connected)
self.remote_stream.read_until_close(self._on_feedback_service_read_close,
self._on_feedback_service_read_streaming)
def ssl_connection(connection):
try:
ssl_connection = ssl.wrap_socket(connection, **sslkwargs)
return iostream.SSLIOStream(ssl_connection)
except (ssl.SSLError, socket.error) as e:
if e.errno == ssl.SSL_ERROR_EOF or e.errno == errno.ECONNABORTED:
ssl_connection.close()
return
def open_twitter_stream(self):
address_info = socket.getaddrinfo(self.host, 443, socket.AF_INET,
socket.SOCK_STREAM, 0, 0)
af, sock_type, protocol = address_info[0][:3]
socket_address = address_info[0][-1]
sock = socket.socket(af, sock_type, protocol)
self.stream = iostream.SSLIOStream(sock)
self.stream.set_close_callback(self.on_close)
self.stream.connect(socket_address, self._on_connect)
def connect(self):
""" Setup socket """
self.sock = socket(AF_INET, SOCK_STREAM)
self.remote_stream = iostream.SSLIOStream(self.sock,
ssl_options=dict(
certfile=self.certfile,
keyfile=self.keyfile))
self.remote_stream.connect(self.apnsendpoint,
self._on_remote_connected)
self.remote_stream.read_until_close(self._on_remote_read_close)
def __init__(self, url, protocols=None, extensions=None, io_loop=None):
WebSocketBaseClient.__init__(self, url, protocols, extensions)
if self.scheme == "wss":
self.sock = ssl.wrap_socket(self.sock,
do_handshake_on_connect=False)
self.io = iostream.SSLIOStream(self.sock, io_loop)
else:
self.io = iostream.IOStream(self.sock, io_loop)
self.sender = self.io.write
self.io_loop = io_loop
def connect(self, timeout=30):
self.clear_reconnect()
if self.closed:
return
self.reset()
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
if self.ssl_options:
self.stream = iostream.SSLIOStream(sock, io_loop=self.io_loop, ssl_options=self.ssl_options)
else:
self.stream = iostream.IOStream(sock, io_loop=self.io_loop)
self.stream.set_close_callback(self.on_close)
if timeout > 0:
self.timeout_cb = self.io_loop.add_timeout(time.time()+timeout, self.connect_timeout)
self.stream.connect((self.host, self.port), self.on_connect)
def _get_ssl_socket(self, stream, **kwargs):
# This makes it simpler for SMTP_SSL to use the SMTP connect code
# and just alter the socket connection bit.
callback = kwargs.pop('callback')
if hasattr(self, '__get_ssl_socket'):
callback(self.__get_ssl_socket)
return
s = ssl.wrap_socket(stream.socket,
do_handshake_on_connect=False,
**kwargs)
stream.close()
stream = iostream.SSLIOStream(s)
self.__get_ssl_socket = stream
callback(stream)
def send_notification_async(self,
device_token_hex,
payload,
callback=None):
self.device_token_hex = device_token_hex
self.payload = payload
self.callback = callback
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
self.stream = iostream.SSLIOStream(s,
ssl_options={
"keyfile": self.KEY_FILE,
"certfile": self.CERT_FILE
})
self.stream.set_close_callback(self.close_callback)
self.stream.connect(self.host_port(), self.send_data)
def connect(self, callback):
# Establish an SSL connection
if not self._connecting:
self._connecting = True
_ioloop = ioloop.IOLoop.instance()
self._connect_timeout = _ioloop.add_timeout(
time.time() + TIME_OUT, self._connecting_timeout_callback)
self._socket = socket(AF_INET, SOCK_STREAM)
self._stream = iostream.SSLIOStream(socket=self._socket,
ssl_options={
"keyfile": self.key_file,
"certfile": self.cert_file
})
self._stream.connect((self.server, self.port),
functools.partial(self._on_connected,
callback))
def main():
delim = '\r\n\r\n'
def send_request():
print "sending OK"
stream.write("OK")
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
# stream = iostream.IOStream(s)
stream = iostream.SSLIOStream(s,
ssl_options=dict(ca_certs="mycert.pem",
cert_reqs=ssl.CERT_NONE))
print "about to connect"
stream.connect(('', 8013), send_request)
ioloop.IOLoop.instance().start()
def open(self, timeout=DEFAULT_CONNECT_TIMEOUT):
logger.debug('socket connecting')
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
if self.ssl_options is None:
self.stream = iostream.IOStream(sock)
else:
self.stream = iostream.SSLIOStream(sock,
ssl_options=self.ssl_options)
try:
yield self.with_timeout(
timeout, self.stream.connect((self.host, self.port)))
except (socket.error, OSError, IOError):
message = 'could not connect to {}:{}'.format(self.host, self.port)
raise TTransportException(type=TTransportException.NOT_OPEN,
message=message)
self._set_close_callback()
raise gen.Return(self)
def __init__(self, connection):
self.connection = connection
# Start socket
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
if connection.options["secure"]:
cert_dir = os.path.split(data.__file__)[0]
cert_file = os.path.join(cert_dir, "flotype.crt")
ssl.wrap_socket(self.socket, cert_reqs=ssl.CERT_REQUIRED, \
ca_certs=cert_file)
# Use SSL IO Stream for secure connection
self.stream = iostream.SSLIOStream(self.socket)
else:
# Create IOStream for TCP connection
self.stream = iostream.IOStream(self.socket)
server = (self.connection.options['host'],
self.connection.options['port'])
self.stream.connect(server, self.onopen)
self.stream.set_close_callback(self.connection.onclose)
def _create_stream(self, sock):
if self.options.use_ssl:
# In Python 3, Tornado's ssl_options_to_context fails if
# any options are None.
ssl_options = {}
if self.options.certfile:
ssl_options['certfile'] = self.options.certfile
if self.options.keyfile:
ssl_options['keyfile'] = self.options.keyfile
if self.options.ca_certs:
ssl_options['ca_certs'] = self.options.ca_certs
if self.options.cert_reqs:
ssl_options['cert_reqs'] = self.options.cert_reqs
return iostream.SSLIOStream(sock,
ssl_options=ssl_options,
io_loop=self.io_loop)
else:
return iostream.IOStream(sock, io_loop=self.io_loop)
def __init__(self, loop, url, **kwargs):
ports = {'ws': 80, 'wss': 443}
self.loop = loop
self._io_loop = IOLoop(_loop=loop)
self.url = urlparse(url)
self.scheme = self.url.scheme
self.host = self.url.hostname
self.port = self.url.port or ports[self.url.scheme]
self.path = self.url.path or '/'
# support the query argument in the path
self.path += self.url.query and "?%s" % self.url.query or ""
self.client_terminated = False
self.server_terminated = False
self._final_frame = False
self._frame_opcode = None
self._frame_length = None
self._fragmented_message_buffer = None
self._fragmented_message_opcode = None
self._waiting = None
self._pending_messages = []
self._started = False
self.key = base64.b64encode(os.urandom(16))
# initialize the stream
if 'ssl_options' in kwargs:
self.stream = iostream.SSLIOStream(socket.socket(),
io_loop=self._io_loop,
**kwargs)
else:
self.stream = iostream.IOStream(socket.socket(),
io_loop=self._io_loop)
self.graceful_shutdown = kwargs.get('graceful_shutdown', 0)
def __init__(self, parent, io_loop=None):
self._parent = parent
self._closing = False
self._user_queries = {}
self._cursor_cache = {}
self._ready = Future()
self._io_loop = io_loop
if self._io_loop is None:
self._io_loop = IOLoop.current()
self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
self._socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
if len(self._parent.ssl) > 0:
ssl_options = {}
if self._parent.ssl["ca_certs"]:
ssl_options['ca_certs'] = self._parent.ssl["ca_certs"]
ssl_options['cert_reqs'] = 2 # ssl.CERT_REQUIRED
self._stream = iostream.SSLIOStream(self._socket,
ssl_options=ssl_options,
io_loop=self._io_loop)
else:
self._stream = iostream.IOStream(self._socket,
io_loop=self._io_loop)
server_side=True,
do_handshake_on_connect=False,
**self.ssl_options)
except ssl.SSLError, err:
if err.args[0] == ssl.SSL_ERROR_EOF:
return connection.close()
else:
raise
except socket.error, err:
if err.args[0] == errno.ECONNABORTED:
return connection.close()
else:
raise
try:
if self.ssl_options is not None:
stream = iostream.SSLIOStream(connection,
io_loop=self.io_loop)
else:
stream = iostream.IOStream(connection,
io_loop=self.io_loop)
TCPConnection(stream, address, self.protocol, self.handler)
except:
logging.error("Error in connection callback", exc_info=True)
class _BadRequestException(Exception):
"""Exception class for malformed requests."""
pass
class TCPConnection(object):
"""Handles a connection to an TCP client, executing requests.
def connect(self, host):
self.sock.connect(host)
self.sock = ssl.wrap_socket(self.sock, do_handshake_on_connect=False)
self.stream = iostream.SSLIOStream(self.sock)
