def on_message(self, msg):
data = proto.json_decode(msg)
if data['type'] == 'auth':
if bool(data.get('sid', None)):
try:
int(data['sid']) # check that sid is number, not word
self.user_sid = data['sid']
self.user_login = yield tornado.gen.Task(
self.client.hget, 'sid:login:all', self.user_sid)
self.users[self.user_sid] = self
self.user_timezone = yield tornado.gen.Task(
self.client.hget, 'timezones', self.user_sid)
self.timezones[self.user_sid] = self.user_timezone
self.authenticated = True
self.send(
proto.json_encode({
"body": "You was authorized",
'type': 'alert'
}))
except Exception, e:
logging.info("bad user's sid: " + str(data['sid']))
else:
self.send(
proto.json_encode({
"body": "You did not authorize",
'type': 'alert'
}))
self.close()
def on_message(self, message):
message = proto.json_decode(message)
if 'channel' in message:
self._channel = message['channel']
self._start_view_log()
self.loop = tornado.ioloop.PeriodicCallback(self._check_new_message, 1000)
self.loop.start()
def send_message(self, msg):
# TODO: Optimize - get rid of double JSON encoding?
decoded = proto.json_decode(msg)
if not isinstance(decoded, basestring):
raise Exception('Can only send strings over raw websocket transport')
self.handler.send_pack(decoded)
def post(self, session_id):
self.preflight()
self.handle_session_cookie()
self.disable_cache()
session = self._get_session(session_id)
if session is None:
self.set_status(404)
return
#data = self.request.body.decode('utf-8')
data = bytes_to_str(self.request.body)
ctype = self.request.headers.get('Content-Type', '').lower()
if ctype == 'application/x-www-form-urlencoded':
if not data.startswith('d='):
logging.exception('jsonp_send: Invalid payload.')
self.write("Payload expected.")
self.set_status(500)
return
data = unquote_plus(data[2:])
if not data:
logging.debug('jsonp_send: Payload expected.')
self.write("Payload expected.")
self.set_status(500)
return
try:
messages = proto.json_decode(data)
except:
# TODO: Proper error handling
logging.debug('jsonp_send: Invalid json encoding')
self.write("Broken JSON encoding.")
self.set_status(500)
return
try:
session.on_messages(messages)
except Exception:
logging.exception('jsonp_send: on_message() failed')
session.close()
self.write('Message handler failed.')
self.set_status(500)
return
self.write('ok')
self.set_header('Content-Type', 'text/plain; charset=UTF-8')
self.set_status(200)
def post(self, session_id):
self.preflight()
self.handle_session_cookie()
session = self._get_session(session_id)
if session is None:
self.set_status(404)
return
#data = self.request.body.decode('utf-8')
data = self.request.body
ctype = self.request.headers.get('Content-Type', '').lower()
if ctype == 'application/x-www-form-urlencoded':
if not data.startswith('d='):
logging.exception('jsonp_send: Invalid payload.')
self.write("Payload expected.")
self.set_status(500)
return
data = urllib.unquote_plus(data[2:])
if not data:
logging.debug('jsonp_send: Payload expected.')
self.write("Payload expected.")
self.set_status(500)
return
try:
messages = proto.json_decode(data)
except:
# TODO: Proper error handling
logging.debug('jsonp_send: Invalid json encoding')
self.write("Broken JSON encoding.")
self.set_status(500)
return
try:
for m in messages:
session.on_message(m)
except Exception:
logging.exception('jsonp_send: on_message() failed')
session.close()
self.write('Message handler failed.')
self.set_status(500)
return
self.write('ok')
self.set_header('Content-Type', 'text/plain; charset=UTF-8')
self.set_status(200)
def post(self, session_id):
self.preflight()
self.handle_session_cookie()
self.disable_cache()
session = self._get_session(session_id)
if session is None:
self.set_status(404)
return
# data = self.request.body.decode('utf-8')
data = bytes_to_str(self.request.body)
ctype = self.request.headers.get("Content-Type", "").lower()
if ctype == "application/x-www-form-urlencoded":
if not data.startswith("d="):
logging.exception("jsonp_send: Invalid payload.")
self.write("Payload expected.")
self.set_status(500)
return
data = unquote_plus(data[2:])
if not data:
logging.debug("jsonp_send: Payload expected.")
self.write("Payload expected.")
self.set_status(500)
return
try:
messages = proto.json_decode(data)
except:
# TODO: Proper error handling
logging.debug("jsonp_send: Invalid json encoding")
self.write("Broken JSON encoding.")
self.set_status(500)
return
try:
session.on_messages(messages)
except Exception:
logging.exception("jsonp_send: on_message() failed")
session.close()
self.write("Message handler failed.")
self.set_status(500)
return
self.write("ok")
self.set_header("Content-Type", "text/plain; charset=UTF-8")
self.set_status(200)
def dispatch(self, instance, msg):
log.info(msg)
command = proto.json_decode(msg)
event = command.get('event')
data = command.get('data')
handler = self._handlers.get(event)
if not handler:
log.warning('Unknown event %s', event)
return
handler(instance, command, data)
def on_message(self, message):
# SockJS requires that empty messages should be ignored
if not message or not self.session:
return
try:
msg = proto.json_decode(bytes_to_str(message))
if isinstance(msg, list):
self.session.on_messages(msg)
else:
self.session.on_messages((msg,))
except Exception:
LOG.exception('WebSocket')
# Close session on exception
self.session_closed()
def on_message(self, message):
# Ignore empty messages
if not message or not self.session:
return
try:
msg = proto.json_decode(message)
# TODO: Clean me up
if isinstance(msg, list):
for m in msg:
self.session.on_message(m)
else:
self.session.on_message(msg)
except Exception:
logging.exception('WebSocket incoming')
# Close session on exception
self.close()
def on_message(self, message):
# Ignore empty messages
if not message or not self.session:
return
try:
msg = proto.json_decode(message)
# TODO: Clean me up
if isinstance(msg, list):
for m in msg:
self.session.on_message(m)
else:
self.session.on_message(msg)
except Exception:
logging.exception('WebSocket incoming')
# Close session on exception
self.close()
def on_message(self, msg):
data = proto.json_decode(msg)
if data['type'] == 'auth':
if bool(data.get('sid', None)):
try:
int(data['sid']) # check that sid is number, not word
self.user_sid = data['sid']
self.user_login = yield tornado.gen.Task(self.client.hget, 'sid:login:all', self.user_sid)
self.users[self.user_sid] = self
self.user_timezone = yield tornado.gen.Task(self.client.hget, 'timezones', self.user_sid)
self.timezones[self.user_sid] = self.user_timezone
self.authenticated = True
self.send(proto.json_encode({"body": "You was authorized", 'type': 'alert'}))
except Exception, e:
logging.info("bad user's sid: " + str(data['sid']))
else:
self.send(proto.json_encode({"body": "You did not authorize", 'type': 'alert'}))
self.close()
def on_message(self, message):
# SockJS requires that empty messages should be ignored
if not message or not self.session:
return
try:
msg = proto.json_decode(message)
if isinstance(msg, list):
self.session.on_messages(msg)
else:
self.session.on_messages((msg,))
except Exception:
logging.exception("WebSocket")
# Close session on exception
# self.session.close()
# Close running connection
self.abort_connection()
def on_message(self, message):
# SockJS requires that empty messages should be ignored
if not message or not self.session:
return
try:
msg = proto.json_decode(bytes_to_str(message))
if isinstance(msg, list):
self.session.on_messages(msg)
else:
self.session.on_messages((msg, ))
except Exception:
LOG.exception('WebSocket')
# Close session on exception
#self.session.close()
# Close running connection
self.abort_connection()
def on_message(self, message):
# Ignore empty messages
if not message or not self.session:
return
try:
msg = proto.json_decode(message)
if isinstance(msg, list):
self.session.on_messages(msg)
else:
self.session.on_messages((msg,))
except Exception:
logging.exception('WebSocket')
# Close session on exception
#self.session.close()
# Close running connection
self.abort_connection()
def post(self, session_id):
self.preflight()
self.handle_session_cookie()
self.disable_cache()
session = self._get_session(session_id)
if session is None:
self.set_status(404)
return
#data = self.request.body.decode('utf-8')
data = self.request.body
if not data:
self.write("Payload expected.")
self.set_status(500)
return
try:
messages = proto.json_decode(data)
except:
# TODO: Proper error handling
self.write("Broken JSON encoding.")
self.set_status(500)
return
try:
session.on_messages(messages)
except Exception:
logging.exception('XHR incoming')
session.close()
self.set_status(500)
return
self.set_status(204)
self.set_header('Content-Type', 'text/plain; charset=UTF-8')
def post(self, session_id, *args, **kwargs):
self.preflight()
self.handle_session_cookie()
self.disable_cache()
session = self._get_session(session_id)
if session is None:
self.set_status(404)
return
#data = self.request.body.decode('utf-8')
data = self.request.body
if not data:
self.write("Payload expected.")
self.set_status(500)
return
try:
messages = proto.json_decode(data)
except:
# TODO: Proper error handling
self.write("Broken JSON encoding.")
self.set_status(500)
return
try:
session.on_messages(messages)
except Exception:
logging.exception('XHR incoming')
session.close()
self.set_status(500)
return
self.set_status(204)
self.set_header('Content-Type', 'text/plain; charset=UTF-8')
def on_message(self, message):
print "send_msg_to_tornado"
print "send_msg_to_tornado " + message
data = proto.json_decode(
message.replace('\r', '\\r').replace('\n', '\\n'))
if data['type'] == 'auth':
self.thread_id = data['thread_id']
try:
self.user_id = self.django_session["_auth_user_id"]
try:
self.sender_name = User.objects.get(
id=self.user_id).username
except OperationalError:
connection.close()
self.sender_name = User.objects.get(
id=self.user_id).username
except (KeyError, User.DoesNotExist):
self.close()
return
if not Thread.objects.filter(
id=self.thread_id, participants__id=self.user_id).exists():
self.close()
return
self.channel = "".join(['thread_', self.thread_id, '_messages'])
self.channel2 = "".join(['thread_', self.thread_id, '_notice'])
yield tornado.gen.Task(self.client.subscribe,
[self.channel, self.channel2])
#self.client.subscribe(self.channel)
#self.client.subscribe(self.channel2)
self.client.listen(self.show_new_message)
if data['type'] == 'message':
if not data['message']:
return
if len(data['message']) > 10000:
return
redis_client.publish(
self.channel,
json.dumps({
"name": "message",
"timestamp": int(time.time()),
"sender": self.sender_name,
"text": data['message'],
}))
http_client = tornado.httpclient.AsyncHTTPClient()
request = tornado.httpclient.HTTPRequest(
"".join(
[settings.SEND_MESSAGE_API_URL, "/", self.thread_id, "/"]),
method="POST",
body=urllib.urlencode({
"message":
data['message'].encode("utf-8"),
"api_key":
settings.API_KEY,
"sender_id":
self.user_id,
}))
http_client.fetch(request, self.handle_request)
if data['type'] == 'typing':
if int(data['typing']):
c.publish(
self.channel2,
json.dumps({
"name": "typing",
"sender": self.sender_name,
"typing": 1
}))
else:
c.publish(
self.channel2,
json.dumps({
"name": "typing",
"sender": self.sender_name,
"typing": 0
}))
