def receive(self, text_data=None, bytes_data=None, **kwargs):
Presence.objects.touch(self.channel_name)
try:
printer = Printer.with_archived.get(id=self.current_printer().id)
if text_data:
data = json.loads(text_data)
else:
data = bson.loads(bytes_data)
if 'janus' in data:
channels.send_janus_to_web(self.current_printer().id, data.get('janus'))
elif 'http.tunnel' in data:
redis.octoprinttunnel_http_response_set(
data['http.tunnel']['ref'],
data['http.tunnel']
)
elif 'ws.tunnel' in data:
channels.send_message_to_octoprinttunnel(
channels.octoprinttunnel_group_name(self.current_printer().id),
data['ws.tunnel'],
)
elif 'passthru' in data:
channels.send_message_to_web(printer.id, data)
else:
process_octoprint_status(printer, data)
except ObjectDoesNotExist:
import traceback; traceback.print_exc()
self.close()
except: # sentry doesn't automatically capture consumer errors
import traceback; traceback.print_exc()
self.close()
sentryClient.captureException()
def connect(self):
try:
# Exception for un-authenticated or un-authorized access
self.printer = Printer.objects.select_related('user').get(
user=self.current_user(),
id=self.scope['url_route']['kwargs']['printer_id'])
self.accept()
self.path = self.scope['path'][len(f'/ws/octoprint/{self.printer.id}'):] # FIXME
self.ref = self.scope['path']
async_to_sync(self.channel_layer.group_add)(
channels.octoprinttunnel_group_name(self.printer.id),
self.channel_name,
)
channels.send_msg_to_printer(
self.printer.id,
{
'ws.tunnel': {
'ref': self.ref,
'data': None,
'path': self.path,
'type': 'connect',
},
'as_binary': True,
})
except:
LOGGER.exception("Websocket failed to connect")
self.close()
def connect(self):
self.user, self.printer = None, None
try:
# Exception for un-authenticated or un-authorized access
self.user, self.printer = self.get_user_and_printer()
if self.printer is None:
self.close()
return
self.accept()
self.path = self.scope['path']
self.ref = str(time.time())
async_to_sync(self.channel_layer.group_add)(
channels.octoprinttunnel_group_name(self.printer.id),
self.channel_name,
)
channels.send_msg_to_printer(
self.printer.id, {
'ws.tunnel': {
'ref': self.ref,
'data': None,
'path': self.path,
'type': 'connect',
},
'as_binary': True,
})
except Exception:
LOGGER.exception("Websocket failed to connect")
self.close()
def receive(self, text_data=None, bytes_data=None, **kwargs):
if time.time() - self.last_touch > TOUCH_MIN_SECS:
self.last_touch = time.time()
Presence.objects.touch(self.channel_name)
try:
if text_data:
data = json.loads(text_data)
else:
data = bson.loads(bytes_data)
if 'janus' in data:
channels.send_janus_to_web(
self.printer.id, data.get('janus'))
elif 'http.tunnel' in data:
cache.octoprinttunnel_http_response_set(
data['http.tunnel']['ref'],
data['http.tunnel']
)
elif 'http.tunnelv2' in data:
cache.octoprinttunnel_http_response_set(
data['http.tunnelv2']['ref'],
data['http.tunnelv2']
)
elif 'ws.tunnel' in data:
channels.send_message_to_octoprinttunnel(
channels.octoprinttunnel_group_name(self.printer.id),
data['ws.tunnel'],
)
elif 'passthru' in data:
channels.send_message_to_web(self.printer.id, data)
else:
printer = Printer.with_archived.annotate(
ext_id=F('current_print__ext_id')
).get(id=self.printer.id)
ex: Optional[Exception] = None
data['_now'] = now()
try:
process_octoprint_status(printer, data)
self.anomaly_tracker.track(printer, data)
except ResurrectionError as ex:
self.anomaly_tracker.track(printer, data, ex)
except ObjectDoesNotExist:
import traceback
traceback.print_exc()
self.close()
except Exception: # sentry doesn't automatically capture consumer errors
import traceback
traceback.print_exc()
sentryClient.captureException()
def disconnect(self, close_code):
LOGGER.warn("OctoPrintConsumer: Closed websocket with code: {}".format(close_code))
async_to_sync(self.channel_layer.group_discard)(
channels.octo_group_name(self.current_printer().id),
self.channel_name
)
Room.objects.remove(channels.octo_group_name(self.current_printer().id), self.channel_name)
# disconnect all octoprint tunnels
channels.send_message_to_octoprinttunnel(
channels.octoprinttunnel_group_name(self.current_printer().id),
{'type': 'octoprint_close', 'ref': 'ALL'},
)
async def disconnect(self, close_code):
LOGGER.warn("OctoPrintConsumer: Closed websocket with code: {}".format(
close_code))
await self.channel_layer.group_discard(self.group_name,
self.channel_name)
await channels.async_broadcast_ws_connection_change(self.group_name)
# disconnect all octoprint tunnels
await channels.async_send_message_to_octoprinttunnel(
channels.octoprinttunnel_group_name(self.current_printer().id),
{
'type': 'octoprint_close',
'ref': 'ALL'
},
)
async def receive(self, text_data=None, bytes_data=None, **kwargs):
await channels.async_touch_channel(self.group_name, self.channel_name)
try:
if text_data:
data = json.loads(text_data)
else:
data = bson.loads(bytes_data)
if 'janus' in data:
await channels.async_send_janus_to_web(
self.current_printer().id, data.get('janus'))
elif 'http.tunnel' in data:
cache.octoprinttunnel_http_response_set(
data['http.tunnel']['ref'], data['http.tunnel'])
elif 'ws.tunnel' in data:
await channels.async_send_message_to_octoprinttunnel(
channels.octoprinttunnel_group_name(
self.current_printer().id),
data['ws.tunnel'],
)
elif 'passthru' in data:
await channels.async_send_message_to_web(
self.current_printer().id, data)
else:
printer = await database_sync_to_async(
Printer.with_archived.annotate(
ext_id=F('current_print__ext_id')).get
)(id=self.current_printer().id)
ex: Optional[Exception] = None
data['_now'] = now()
try:
await database_sync_to_async(process_octoprint_status)(
printer, data)
await database_sync_to_async(self.anomaly_tracker.track
)(printer, data)
except ResurrectionError as ex:
await database_sync_to_async(self.anomaly_tracker.track
)(printer, data, ex)
except ObjectDoesNotExist:
import traceback
traceback.print_exc()
await self.close()
except Exception: # sentry doesn't automatically capture consumer errors
import traceback
traceback.print_exc()
await database_sync_to_async(sentryClient.captureException)()
def disconnect(self, close_code):
LOGGER.warn(f'OctoprintTunnelWebConsumer: Closed websocket with code: {close_code}')
async_to_sync(self.channel_layer.group_discard)(
channels.octoprinttunnel_group_name(self.printer.id),
self.channel_name,
)
channels.send_msg_to_printer(
self.printer.id,
{
'ws.tunnel': {
'ref': self.ref,
'data': None,
'path': self.path,
'type': 'tunnel_close',
},
'as_binary': True,
})
