def send_and_receive(self, command, **kwargs):
# self.log_debug("send_and_receive: message %s" % command)
# exit the loop if timeout happens
timeout_timer = QtCore.QTimer(
parent=QtCore.QCoreApplication.instance())
loop = QtCore.QEventLoop()
data = None
def await_for_response(result):
self.send_and_receive.data = result
# self.log_debug("exiting the loop: result %s" % result)
loop.quit()
# self.log_debug("in the loop...")
self.send_text_message(command,
callback=await_for_response,
**kwargs)
timeout_timer.timeout.connect(loop.quit)
timeout_timer.start(5 * 1000.0)
loop.exec_()
return self.send_and_receive.data
def show(self, pos=None):
pos = QtGui.QCursor.pos() if pos is None else QtCore.QPoint(pos[0], pos[1])
qApp = QtWidgets.QApplication.instance()
# qApp.setWindowState(QtCore.Qt.WindowActive)
self.menu_handle.activateWindow()
self.menu_handle.raise_()
self.menu_handle.exec_(pos)
def _jump_to_sg(self):
"""
Jump to shotgun, launch web browser
"""
url = self._engine.context.shotgun_url
QtGui.QDesktopServices.openUrl(QtCore.QUrl(url))
def connect_to_server(self):
self.log_debug("Client start connection | %s " % QtCore.QUrl(self.url))
result = self.client.open(QtCore.QUrl(self.url))
self.log_debug("Client start connection | result | %s " % result)
class Client(QtCore.QObject):
requestReceived = QtCore.Signal(str, object)
def __init__(self, engine, parent=None, url="ws://localhost:12345"):
super(Client, self).__init__(parent)
self.engine = engine
self.url = url
self.client = QtWebSockets.QWebSocket(
"", QtWebSockets.QWebSocketProtocol.Version13, None)
self.client.connected.connect(self.on_connected)
self.client.disconnected.connect(self.on_disconnected)
self.client.error.connect(self.on_error)
self.client.stateChanged.connect(self.on_state_changed)
self.client.pong.connect(self.on_pong)
self.client.textMessageReceived.connect(self.on_text_message_received)
self.callbacks = {}
self.max_attemps = 5
self.wait_period = 1
# borrow the engine logger
self.log_info = engine.log_info
self.log_debug = engine.log_debug
self.log_warning = engine.log_warning
self.log_error = engine.log_error
self.log_debug("Client started. - %s " % url)
# A bit of a hack to get responses from the server
# I cannot wait for python3 concurrency!
# reference: https://stackoverflow.com/questions/9523370/adding-attributes-to-instance-methods-in-python
def send_and_receive(self, command, **kwargs):
# self.log_debug("send_and_receive: message %s" % command)
# exit the loop if timeout happens
timeout_timer = QtCore.QTimer(
parent=QtCore.QCoreApplication.instance())
loop = QtCore.QEventLoop()
data = None
def await_for_response(result):
self.send_and_receive.data = result
# self.log_debug("exiting the loop: result %s" % result)
loop.quit()
# self.log_debug("in the loop...")
self.send_text_message(command,
callback=await_for_response,
**kwargs)
timeout_timer.timeout.connect(loop.quit)
timeout_timer.start(5 * 1000.0)
loop.exec_()
return self.send_and_receive.data
self.send_and_receive = partial(send_and_receive, self)
# connect to server
self.connect_to_server()
def connect_to_server(self):
self.log_debug("Client start connection | %s " % QtCore.QUrl(self.url))
result = self.client.open(QtCore.QUrl(self.url))
self.log_debug("Client start connection | result | %s " % result)
def ping(self):
self.log_debug("client: do_ping")
self.client.ping()
def on_connected(self):
pass
self.log_debug("client: on_connected")
def on_disconnected(self):
self.log_debug("client: on_disconnected")
self.engine.process_request("QUIT")
def on_error(self, error_code):
self.log_error("client: on_error: {}".format(error_code))
self.log_error(self.client.errorString())
self.engine.process_request("QUIT")
def on_state_changed(self, state):
self.log_debug("client: on_state_changed: %s" % state)
state = self.client.state()
if state == QAbstractSocket.SocketState.ConnectingState:
return
attempts = 0
while attempts < self.max_attemps and self.client.state() not in (
QAbstractSocket.SocketState.ConnectedState, ):
attempts += 1
self.log_debug("client: attempted to reconnect : %s" % attempts)
self.connect_to_server()
time.sleep(self.wait_period)
def on_text_message_received(self, message):
# self.log_debug("client: on_text_message_received: %s" % (message))
jsonData = json.loads(message)
message_id = jsonData.get("id")
# requesting data
if jsonData.has_key("method"):
# self.log_debug("client: request detected: %s" % (message))
method = jsonData.get("method")
params = jsonData.get("params")
self.engine.process_request(method, **params)
if jsonData.has_key("result"):
# self.log_debug("client: result detected: %s" % (message))
if message_id in self.callbacks:
# self.log_debug(
# "client: requesting callback result for message: %s"
# % message_id
# )
result = jsonData.get("result")
self.callbacks[message_id](result)
del self.callbacks[message_id]
def send_text_message(self,
command,
message_id=None,
callback=None,
**kwargs):
if self.client.state() in (
QAbstractSocket.SocketState.ClosingState,
QAbstractSocket.SocketState.UnconnectedState,
):
# self.log_debug(
# "client: is not connected!, ignoring message: %s" % message_id
# )
return
# wait until connected
while self.client.state(
) == QAbstractSocket.SocketState.ConnectingState:
QCoreApplication.processEvents()
# self.log_debug("client: waiting state: %s" % self.client.state())
time.sleep(self.wait_period)
pass
if message_id is None:
message_id = uuid.uuid4().hex
if callback:
self.callbacks[message_id] = callback
message = json.dumps({
"jsonrpc": "2.0",
"method": command,
"params": kwargs,
"id": message_id,
})
# self.log_debug("client: send_message: %s" % message)
self.client.sendTextMessage(message)
return message_id
def on_pong(self, elapsedTime, payload):
# self.log_debug(
# "client: onPong - time: {} ; payload: {}".format(
# elapsedTime, payload
# )
# )
pass
def close(self):
self.log_debug("client: closed.")
self.client.close()