def connect(self, url):
request = httpclient.HTTPRequest(url=url,
connect_timeout=self.connect_timeout,
request_timeout=self.request_timeout)
ws_conn = websocket.WebSocketClientConnection(ioloop.IOLoop.current(),
request)
ws_conn.connect_future.add_done_callback(self._connect_callback)
def connect(self, url, port=8080):
"""Connect to the server.
:param str url: complete website url.
:param int port: websocket server port (default: 8080)
"""
# save url and port in global variables
self.port = port
self.url = url
# return the website URLs hostname, i.e.: if self.url was "http://nba-stream.chatango.com" self.host would be "nba-stream"
self.host = emulation.get_chatroom_name(self.url)
# generate WebSocket endpoint address
self.web_socket_endpoint = "ws://{0}:{1}".format(
emulation.get_server_id(url),
self.port,
)
# generate random 16-character unique id (required)
self._generate_uid()
# verify that a valid Account() instances has been passed to the global variable self.account
#if isinstance(self.account, Account):
if self.account:
self.auth = self.account.login()
else:
raise ValueError, "You must set the global variable self.account to an Account() instance!"
# update http-headers with authentication token(s)
http_headers = HTTPHEADERS
http_headers.update(self.auth)
headers = httputil.HTTPHeaders(http_headers)
request = httpclient.HTTPRequest(url=self.web_socket_endpoint,
connect_timeout=self.connect_timeout,
request_timeout=self.request_timeout,
headers=headers)
ws_conn = websocket.WebSocketClientConnection(ioloop.IOLoop.current(),
request)
ws_conn.connect_future.add_done_callback(self._connect_callback)
def connect(self, url):
headers = httputil.HTTPHeaders({'Content-Type': APPLICATION_JSON})
request = httpclient.HTTPRequest(url=url,
connect_timeout=self.connect_timeout,
request_timeout=self.request_timeout,
headers=headers)
ws_conn = websocket.WebSocketClientConnection(ioloop.IOLoop.current(),
request)
ws_conn.connect_future.add_done_callback(self._connect_callback)
def _connect(self):
headers = httputil.HTTPHeaders({'Content-Type': APPLICATION_JSON})
request = httpclient.HTTPRequest(url=self._url,
connect_timeout=self.connect_timeout,
request_timeout=self.request_timeout,
headers=headers)
ws_conn = websocket.WebSocketClientConnection(request)
self._ws_connection = ws_conn
ws_conn.connect_future.add_done_callback(self._connect_callback)
def run(self):
if not self.access_key:
raise RuntimeError("Access Key was not set.")
log.info("About to connect to %s", self.brain_api_url)
req = HTTPRequest(self.brain_api_url,
connect_timeout=60,
request_timeout=60)
req.headers['Authorization'] = self.access_key
f = websockets.WebSocketClientConnection(IOLoop.current(), req)
websocket = yield f.connect_future
wrapped = _WrapSocket(websocket)
input_message = None
try:
# The driver starts out in an unregistered... the first "next" will
# perform the registration and all subsequent "next"s will continue
# the operation.
while self.driver.state != DriverState.FINISHED:
if self.recording_file:
yield self._record('RECV', input_message)
output_message = self.driver.next(input_message)
if self.recording_file:
yield self._record('SEND', output_message)
# If the driver is FINSIHED, don't bother sending and
# receiving again before exiting the loop.
if self.driver.state != DriverState.FINISHED:
if not output_message:
raise RuntimeError(
"Driver did not return a message to send.")
output_bytes = output_message.SerializeToString()
yield wrapped.send(output_bytes)
# Only do this part if the last message wasn't a FINISH
input_bytes = yield wrapped.recv()
if input_bytes:
input_message = ServerToSimulator()
input_message.ParseFromString(input_bytes)
else:
input_message = None
except (websockets.WebSocketClosedError, ManualClosedException):
code = websocket.close_code
reason = websocket.close_reason
log.error("Connection to '%s' is closed, code='%s', reason='%s'",
self.brain_api_url, code, reason)
finally:
if self.recording_file:
yield self.recording_queue.put(None)
websocket.close()
def connect(self, url):
"""Connect to the server.
:param str url: server URL.
"""
print("connnection established")
headers = httputil.HTTPHeaders({'Content-Type': APPLICATION_JSON})
request = httpclient.HTTPRequest(url=url, connect_timeout=self.connect_timeout,
request_timeout=self.request_timeout, headers=headers)
ws_conn = websocket.WebSocketClientConnection(ioloop.IOLoop.current(), request)
ws_conn.connect_future.add_done_callback(self._connect_callback)
def connect(self, url):
"""Connect to the server.
:param str url: server URL.
"""
self._connect_status = self.CONNECTING
headers = httputil.HTTPHeaders({'Content-Type': APPLICATION_JSON})
request = httpclient.HTTPRequest(url=url,
connect_timeout=self.connect_timeout,
request_timeout=self.request_timeout,
headers=headers)
ws_conn = websocket.WebSocketClientConnection(self._io_loop, request)
ws_conn.connect_future.add_done_callback(self._connect_callback)
def __init__(self, url, connect_timeout=DEFAULT_CONNECT_TIMEOUT,
request_timeout=DEFAULT_REQUEST_TIMEOUT):
self.connect_timeout = connect_timeout
self.request_timeout = request_timeout
request = httpclient.HTTPRequest(url=url,
connect_timeout=self.connect_timeout,
request_timeout=self.request_timeout)
ws_conn = websocket.WebSocketClientConnection(ioloop.IOLoop.current(),
request)
ws_conn.connect_future.add_done_callback(self._connect_callback)
tornado.ioloop.IOLoop.current().start()
def connect(self, url):
"""Connect to the server.
:param str url: server URL.
"""
logging.info("this client attempt to connect to the server")
self._connect_status = self.CONNECTING
headers = httputil.HTTPHeaders({'Content-Type': APPLICATION_JSON})
request = httpclient.HTTPRequest(url=url,
connect_timeout=self.connect_timeout,
request_timeout=self.request_timeout,
headers=headers)
# this set client sending and receiving max message size limit
ws_conn = websocket.WebSocketClientConnection(request, max_message_size=1024 * 1024 * 1024)
ws_conn.connect_future.add_done_callback(self._connect_callback)
def connect(self, url):
"""Connect to the server.
:param str url: server URL.
"""
self._ioloop = ioloop.IOLoop()
headers = httputil.HTTPHeaders({'Content-Type': APPLICATION_JSON})
request = httpclient.HTTPRequest(url=url,
connect_timeout=self.connect_timeout,
request_timeout=self.request_timeout,
headers=headers)
self.ws_conn = websocket.WebSocketClientConnection(self._ioloop,
request)
self._ioloop.add_future(self.ws_conn.connect_future, self._connect_callback)
def connect(self, io_loop=None, url=None):
"""
Connect to the server.
:param str url: server URL.
"""
if url is None:
url = 'ws://localhost:8878/API-ws/'
if io_loop is None:
io_loop = ioloop.IOLoop.current()
logging.info('Opening websocket to IoT-Backend: %s' % str(url))
headers = httputil.HTTPHeaders({'Content-Type': 'application/json'})
request = httpclient.HTTPRequest(url=url,
connect_timeout=self.connect_timeout,
request_timeout=self.request_timeout,
headers=headers)
ws_conn = websocket.WebSocketClientConnection(io_loop, request)
ws_conn.connect_future.add_done_callback(self.connect_callback)
def websocket_connect(url, io_loop=None, callback=None, connect_timeout=None):
"""Client-side websocket support.
Takes a url and returns a Future whose result is a
`WebSocketClientConnection`.
"""
if io_loop is None:
io_loop = IOLoop.current()
request = httpclient.HTTPRequest(
url,
connect_timeout=connect_timeout,
validate_cert=False, # TODO
)
request = httpclient._RequestProxy(request,
httpclient.HTTPRequest._DEFAULTS)
conn = websocket.WebSocketClientConnection(io_loop, request)
if callback is not None:
io_loop.add_future(conn.connect_future, callback)
return conn.connect_future
def connect(self):
"""Connect to the server.
"""
url = 'wss://dev.flytbase.com/websocket'
headers = httputil.HTTPHeaders({
'Content-Type':
'application/json',
'Authorization':
'Token ' + str(self.api_key),
'VehicleID':
str(self.vehicle_id)
})
request = httpclient.HTTPRequest(url=url,
connect_timeout=self.connect_timeout,
request_timeout=self.request_timeout,
headers=headers)
ws_conn = websocket.WebSocketClientConnection(ioloop.IOLoop.current(),
request)
ws_conn.connect_future.add_done_callback(self._connect_callback)
def connect(self, url):
request = httpclient.HTTPRequest(url=url)
ws_conn = websocket.WebSocketClientConnection(request)
ws_conn.connect_future.add_done_callback(self._connect_callback)
