async def _process_message(self, websocket: Websocket,
message: str) -> None:
message = json.loads(message)
# subscription negative response
if "error" in message or message['type'] == "ERROR":
raise BitpandaException(
f"Subscription error. Request [{json.dumps(self._get_subscription_message())}] Response [{json.dumps(message)}]"
)
# subscription positive response
elif message['type'] == "SUBSCRIPTIONS":
LOG.info(
f"Subscription confirmed for channels [" +
",".join([channel["name"]
for channel in message["channels"]]) + "]")
# for confirmed ORDERS channel publish the confirmation downstream in order to communicate the websocket handle
if 'ORDERS' in [
channel['name'] for channel in message['channels']
]:
await self.publish_message(
WebsocketMessage(
subscription_id='ORDERS',
message=message,
websocket=ClientWebsocketHandle(websocket=websocket)))
# remote termination with an opportunity to reconnect
elif message["type"] == "CONNECTION_CLOSING":
LOG.warning(
f"Server is performing connection termination with an opportunity to reconnect."
)
raise WebsocketReconnectionException(
"Graceful connection termination.")
# heartbeat message
elif message["type"] == "HEARTBEAT":
pass
# regular message
else:
await self.publish_message(
WebsocketMessage(
subscription_id=message['channel_name'],
message=message,
# for ORDERS channel communicate also the websocket handle
websocket=ClientWebsocketHandle(websocket=websocket)
if message['channel_name'] == 'ORDERS' else None))
async def _process_message(self, websocket: Websocket,
message: str) -> None:
message = json.loads(message)
if message['event'] == "pusher:connection_established":
pass
elif message['event'] == "pusher:pong":
pass
elif message['event'] == "quoine:auth_success":
subscription_messages = []
for subscription in self.subscriptions:
subscription_message = subscription.get_subscription_message()
subscription_messages.append(subscription_message)
LOG.debug(f"> {subscription_messages}")
await websocket.send(json.dumps(subscription_messages))
elif message['event'] == "quoine:auth_failure":
raise LiquidException(f"Websocket authentication error: {message}")
elif message['event'] == "pusher_internal:subscription_succeeded":
LOG.info(f'Websocket subscribed successfuly: {message}')
elif message['event'] == "updated":
await self.publish_message(
WebsocketMessage(subscription_id=message['channel'],
message=message))
else:
raise LiquidException(f"Websocket unknown event type: {message}")
async def _process_message(self,
websocket: websockets.WebSocketClientProtocol,
message: str) -> None:
message = json.loads(message)
# subscription negative response
if 'action' in message and message[
'action'] == 'subscribe' and "error" in message:
raise BitvavoException(
f"Subscription error. Response [{json.dumps(message)}]")
# subscription positive response
if 'event' in message and message['event'] == 'subscribed':
if len(message['subscriptions']) > 0:
LOG.info(
f"Subscription confirmed for channels [{message['subscriptions']}]"
)
else:
raise BitvavoException(
f"Subscription error. No subscription confirmed. Response [{json.dumps(message)}]"
)
# regular message
else:
await self.publish_message(
WebsocketMessage(
subscription_id=self._map_event_id_to_subscription_id(
message['event']),
message=message))
async def _process_message(self, websocket: Websocket,
message: str) -> None:
message = json.loads(message)
topic = message['topic']
channel = topic.split(':')[0]
await self.publish_message(
WebsocketMessage(subscription_id=channel, message=message))
async def _process_message(self, websocket: Websocket,
message: str) -> None:
message = json.loads(message)
# data message
if "event" in message and message['event'] == "data":
await self.publish_message(
WebsocketMessage(subscription_id=message['channel'],
message=message))
async def _process_message(self, websocket: Websocket,
message: str) -> None:
if message != BitforexWebsocket.PONG_MSG:
message = json.loads(message)
subscription_id = BitforexSubscription.make_subscription_id(
message['event'], message['param'])
await self.publish_message(
WebsocketMessage(subscription_id=subscription_id,
message=message))
async def _process_message(self, websocket: Websocket,
message: str) -> None:
message = json.loads(message)
if self._is_subscription_confirmation(message):
LOG.info(f"Subscription confirmed for id: {message['id']}")
else:
# regular message
await self.publish_message(
WebsocketMessage(subscription_id=message['stream'],
message=message))
async def _process_message(self, websocket: Websocket, message: str) -> None:
message = json.loads(message)
if 'id' in message and 'result' in message and message['result'] == True:
# subscription confirmation
# for confirmed account channel publish the confirmation downstream in order to communicate the websocket handle
for subscription in self.subscriptions:
if subscription.external_id == message['id'] and subscription.get_subscription_id() == 'account':
await self.publish_message(WebsocketMessage(
subscription_id = 'account',
message = message,
websocket = ClientWebsocketHandle(websocket = websocket)
))
else:
# regular message
subscription_id = self._map_message_to_subscription_id(message)
await self.publish_message(WebsocketMessage(
subscription_id = subscription_id,
message = message,
# for account channel communicate also the websocket handle
websocket = ClientWebsocketHandle(websocket = websocket) if subscription_id == 'account' else None
)
)
async def _process_message(self, websocket: Websocket,
message: str) -> None:
message = json.loads(message)
if 'type' not in message:
LOG.error(
f"ERROR: Message without 'type' property received: {message}")
elif message['type'] == 'pong':
# ignore pong responses
pass
else:
# regular message
subscription_id = self._map_message_to_subscription_id(message)
await self.publish_message(
WebsocketMessage(subscription_id=subscription_id,
message=message))
async def _process_message(self, websocket: Websocket, message: str) -> None:
if message == '#1':
pong = '#2'
LOG.debug(f"> {pong}")
await websocket.send(pong)
return
message = json.loads(message)
if message['e'] == 'empty':
pass
elif message['e'] == 'system':
pass
elif message['e'] == 'reply' and message['status'] == 'ok':
LOG.info("Channel subscribed successfully.")
elif message['e'] == 'reply' and message['status'] == 'error':
raise AAXException(f"Websocket error message received: {message}")
else:
await self.publish_message(WebsocketMessage(subscription_id = self.map_subscription_id(message), message = message))
async def _process_message(self, websocket: Websocket, message: str) -> None:
messages = json.loads(message)
if "ping" in messages:
pong_message = {
"pong": messages['ping']
}
LOG.debug(f"> {pong_message}")
await websocket.send(json.dumps(pong_message))
elif 'error' in messages:
raise BiboxException(f"BiboxException: Bibox error received: {message}")
else:
for message in messages:
if 'data' in message:
data = message['data']
if 'binary' in message and message['binary'] == '1':
data = zlib.decompress(base64.b64decode(data), zlib.MAX_WBITS | 32)
message['data'] = json.loads(data.decode("utf-8"))
await self.publish_message(WebsocketMessage(subscription_id = message['channel'], message = message))
else:
LOG.warning(f"No data element received: {message}")