def send_to_all(cls, message, exclude_websockets=None):
with cls.websockets_lock:
for websocket in cls.websockets:
if not exclude_websockets or websocket not in exclude_websockets:
try:
websocket.write_message(message)
except Exception:
traceback.print_exc()
def on_message(self, message):
global audio_packet_list, writing_file_1, adaptive_buffer
if message:
if len(message) == 400:
# it's an audio packet
print "audio packet received"
if len(audio_packet_list) == 25:
print 'received audio termination request', datetime.now()
audio_array = np.concatenate(audio_packet_list)
audio_packet_list = []
to_send = {
'type': 'audio-array',
'array': audio_array.tolist()
}
for socket in browser_audio_sockets:
socket.write_message(json.dumps(to_send))
print "packets received: ", len(audio_packet_list)
audio_packet_raw = np.frombuffer(message, dtype=np.uint16)
adaptive_buffer = np.roll(adaptive_buffer, 200)
adaptive_buffer[0:200] = audio_packet_raw
adaptive_mean = np.mean(adaptive_buffer)
adaptive_std = np.std(adaptive_buffer)
audio_packet = (audio_packet_raw -
adaptive_mean) / (10.0 * adaptive_std)
audio_packet = np.clip(audio_packet, -1, 1)
audio_packet_list.append(audio_packet)
else:
# it's an image packet - the audio ones are always exactly 200 long
if message == "image done":
print "Full image received"
complete_image = 'images/cam_feed1.jpg' if writing_file_1 else 'images/cam_feed2.jpg'
new_image = 'images/cam_feed2.jpg' if writing_file_1 else 'images/cam_feed1.jpg'
f = open(new_image, 'w')
f.write('')
f.close()
writing_file_1 = not writing_file_1
print "File size", os.stat(complete_image).st_size
for websocket in cam_sockets:
websocket.write_message(complete_image)
else:
print "Image packet received"
filename = 'images/cam_feed1.jpg' if writing_file_1 else 'images/cam_feed2.jpg'
f = open(filename, "ab")
f.write(message)
f.close()
def send_session(websocket):
""" Function to send initial session data over web socket. """
message = {'kind': 'session-data', 'data': globals.sessionData}
jsonmessage = json.dumps(message)
logging.debug(jsonmessage)
websocket.write_message(jsonmessage)
message = {'kind': 'status-update', 'data': {'files': list_files(), 'loading': {}, 'buckets': list_buckets()}}
jsonmessage = json.dumps(message)
logging.debug(jsonmessage)
websocket.write_message(jsonmessage)
def send_messages(websocket, messages, extra=None):
#messages_data = [message_to_dict(m) for m in messages]
messages_data = {
k: message_to_dict(v)
for k, v in messages.items() if is_not_spam(v)
}
to_send = {'messages': messages_data}
if extra:
to_send.update(extra)
websocket.write_message(to_send)
def broadcast(cls, messages):
logging.info("Sending new message to %r listeners", len(cls.websockets))
body_str = json.dumps({"messages": messages})
headers = [('Content-Type', 'text/json')]
status_str = '200 OK'
for websocket in cls.websockets.values():
try:
websocket.write_message(body_str)
except Exception, excp:
logging.warning("ERROR in writing to websocket: %s; closing", excp)
try:
websocket.close()
except Exception:
pass
def new_session(self, user_id, websocket, session_id=None):
"""
Open a new websocket session for a given user
Parameters
user_id ( :py:class:`toyz.utils.core.ToyzUser` ): User id
websocket (:py:class:`toyz.web.app.WebSocketHandler` ): new websocket opened
"""
import datetime
if user_id not in self.user_sessions:
self.user_sessions[user_id] = {}
print("Users logged in:", self.user_sessions.keys())
if session_id is None:
session_id = str(datetime.datetime.now()).replace(
' ', '__').replace('.', '-').replace(':', '_')
self.user_sessions[user_id][session_id] = websocket
shortcuts = db_utils.get_param(self.toyz_settings.db,
'shortcuts',
user_id=user_id)
shortcuts = core.check_user_shortcuts(self.toyz_settings, user_id,
shortcuts)
websocket.session = {
'user_id': user_id,
'session_id': session_id,
'path': os.path.join(shortcuts['temp'], session_id),
}
core.create_paths(websocket.session['path'])
#initialize process for session jobs
websocket.job_pipe, remote_pipe = multiprocessing.Pipe()
websocket.process = multiprocessing.Process(target=job_process,
args=(session_id,
remote_pipe,
websocket.job_pipe))
websocket.process.start()
remote_pipe.close()
process_events = (tornado.ioloop.IOLoop.READ
| tornado.ioloop.IOLoop.ERROR)
tornado.ioloop.IOLoop.current().add_handler(websocket.job_pipe,
websocket.send_response,
process_events)
websocket.write_message({
'id': 'initialize',
'user_id': user_id,
'session_id': session_id,
})
def post(self):
user = self.request.arguments['user'][0]
#construct JSON Object
data = [{'command':'spawnwebsocket', 'user':user}]
jsonObject = json.dumps(data)
for client in listeners.get('admin', ['default']):
websocket = client.webSocket
websocket.write_message(jsonObject)
#websocket = listeners.get('admin',['default'])[0].webSocket
#print 'THE WEBSOCKET = \n\n'
#print websocket
return 'true'
def post(self):
if 'message' in self.request.arguments:
message = self.request.arguments['message'][0]
group = self.request.arguments.get('group', ['default'])[0]
print '%s:MESSAGE to %s:%s' % (time.time(), group, message)
#For every Client Listener in the group specified in post data
for client in listeners.get(group, []):
client.write_message(message)
websocket = listeners.get('admin', ['default'])[0].webSocket
print 'THE WEBSOCKET = \n\n'
print websocket
websocket.write_message(message)
return 'true'
return 'false'
def periodic_check():
#print("Periodic Callback with num sockets: " + str(len(websockets)))
pc.scanlocations()
for websocket in websockets:
items = []
for item in pc.processlist:
itemcontent = {
"hostname": item["hostname"],
"processname": item["processname"],
"hash": item["hash"],
"sshstatus": item["sshstatus"],
"processstatus": item["processstatus"],
"journal": item["journal"]
}
items.append(itemcontent)
msg = {"type": "update", "items": items}
websocket.write_message(json.dumps(msg))
def send_scene(self, websocket):
for node in walk(self.tree):
if node.object is not None:
websocket.write_message(node.object, binary=True)
for p in node.properties:
websocket.write_message(p, binary=True)
if node.transform is not None:
websocket.write_message(node.transform, binary=True)
if node.animation is not None:
websocket.write_message(node.animation, binary=True)
def new_session(self, user_id, websocket, session_id=None):
"""
Open a new websocket session for a given user
Parameters
user_id ( :py:class:`toyz.utils.core.ToyzUser` ): User id
websocket (:py:class:`toyz.web.app.WebSocketHandler` ): new websocket opened
"""
import datetime
if user_id not in self.user_sessions:
self.user_sessions[user_id] = {}
print("Users logged in:", self.user_sessions.keys())
if session_id is None:
session_id = str(
datetime.datetime.now()).replace(' ','__').replace('.','-').replace(':','_')
self.user_sessions[user_id][session_id] = websocket
shortcuts = db_utils.get_param(self.toyz_settings.db, 'shortcuts',
user_id=user_id)
shortcuts = core.check_user_shortcuts(self.toyz_settings, user_id, shortcuts)
websocket.session = {
'user_id': user_id,
'session_id': session_id,
'path': os.path.join(shortcuts['temp'], session_id),
}
core.create_paths(websocket.session['path'])
#initialize process for session jobs
websocket.job_pipe, remote_pipe = multiprocessing.Pipe()
websocket.process = multiprocessing.Process(
target = job_process, args=(session_id, remote_pipe, websocket.job_pipe))
websocket.process.start()
remote_pipe.close()
process_events = (tornado.ioloop.IOLoop.READ | tornado.ioloop.IOLoop.ERROR)
tornado.ioloop.IOLoop.current().add_handler(
websocket.job_pipe, websocket.send_response, process_events)
websocket.write_message({
'id': 'initialize',
'user_id': user_id,
'session_id': session_id,
})
def forward_packet_to_ws_client(reserved_socket: socket.socket,
ws: ws.WebSocketHandler):
asyncio.set_event_loop(asyncio.new_event_loop())
message = ' '
while message:
message = reserved_socket.recv(pw.tcp_bufsize)
#log.info("VCL " + str(message))
if message:
ws.write_message(message=message, binary=binary_type)
else:
try:
reserved_socket.shutdown(SHUT_RD)
except:
pass
try:
ws.close()
pass
except:
pass
pass
def _write_data_response(websocket, data_points):
"""Generates a serialized data message with headers for deserialization.
Writes output to websocket.
"""
assert data_points
model_info = model_meta.get_field_info(TimeSeriesDataPoint)
field_names = TimeSeriesDataPointSerializer(data_points[0])\
.get_field_names({}, model_info)
response = {
'headers': list(field_names),
'data': [],
}
LOGGER.debug("Writing %d datapoints out.", len(data_points))
for data_point in data_points:
serializer = TimeSeriesDataPointSerializer(data_point)
data = serializer.data
data_entry = []
for field_name in field_names:
data_entry.append(data[field_name])
response['data'].append(data_entry)
websocket.write_message(json.dumps(response))
def _write_data_response(websocket, data_points):
"""Generates a serialized data message with headers for deserialization.
Writes output to websocket.
"""
assert data_points
model_info = model_meta.get_field_info(TimeSeriesDataPoint)
field_names = TimeSeriesDataPointSerializer(data_points[0])\
.get_field_names({}, model_info)
response = {
'headers': list(field_names),
'data': [],
}
LOGGER.debug("Writing %d datapoints out.", len(data_points))
for data_point in data_points:
serializer = TimeSeriesDataPointSerializer(data_point)
data = serializer.data
data_entry = []
for field_name in field_names:
data_entry.append(data[field_name])
response['data'].append(data_entry)
websocket.write_message(json.dumps(response))
def do_route(self,target_page_id=None,envelope=None,**kwargs):
websocket=self.channels.get(target_page_id)
if websocket:
websocket.write_message(envelope)
def forward_to_websockets(self, frames):
cmd, path, data = frames
for websocket in self.websocket_pool:
websocket.write_message(data, binary=True)
def send_to_websockets(self, msg):
print("msg:", msg)
for websocket in self.websocket_pool:
websocket.write_message(msg[0])
self.zmq_socket.send(b"ok")
def on_message(self, message):
for websocket in all_websocket:
websocket.write_message(message)
def post(self):
msg = self.get_argument("msg", strip=True)
LOGGER.debug(msg)
for websocket in all_websocket:
websocket.write_message(msg)
def write_message_all(message, binary=False):
s = GithubWebhook.StatusWebSocket
with s.lock:
for websocket in s.websockets:
websocket.write_message(message, binary)
def send_scene(self, websocket):
for node in walk(self.tree):
if node.object is not None:
websocket.write_message(node.object, binary=True)
if node.transform is not None:
websocket.write_message(node.transform, binary=True)
def write_message_all(message, binary=False):
s = GithubWebhook.StatusWebSocket
with s.lock:
for websocket in s.websockets:
websocket.write_message(message, binary)