def __init__(self, handlers, settings):
super(Application, self).__init__(handlers, **settings)
log_from_server('info', 'Initializing DB connection...')
# Have one global connection to the blog DB across all handlers
self.db = torndb.Connection(
host=DB_HOST,
database=DB_SCHEMA,
user=DB_USER,
password=DB_PASSWORD,
charset='utf8mb4'
)
# Save the github auth data for making issues
self.github_username = GITHUB_USERNAME
self.github_token = GITHUB_TOKEN
# user list
self.user_list = UserList(self.db)
# room list
self.room_list = RoomList(self.db, self.user_list)
# private messages
self.private_message_map = PrivateMessageMap(self.user_list)
# message queue
self.message_queue = MessageQueue(self.db, self.user_list)
def __init__(self, db, user_list):
log_from_server('info', 'Initializing room list...')
self.db = db
self._user_list = user_list
self._room_map[0] = {
'name': 'General',
'owner': None,
'id': 0,
'members': set(self._user_list.get_all_usernames()),
'history': deque(maxlen=MAX_DEQUE_LENGTH)
}
rooms = self.db.query(
'SELECT id, name, owner, group_concat(parasite_id) AS members '
'FROM rooms LEFT JOIN room_access a ON rooms.id = a.room_id and a.in_room = TRUE '
'GROUP BY id')
for room in rooms:
if room['members'] is not None:
room['members'] = set(room['members'].split(','))
else:
del room['members']
new_room = self._get_default_room()
new_room.update(room)
self._room_map[room.id] = new_room
def on_open(self, info):
# on initial connection, we need to send the "initialization" information
# the room list (filtered for the user)
# the user list (of current status for users)
# the user's default settings (to be used on the client)
parasite = self.session.handler.get_secure_cookie('parasite')
if parasite is None:
self._send_auth_fail()
return False
log_from_server(
'DEBUG',
'Client ({}:{}) connecting...'.format(parasite,
self.session.session_id))
self._user_list = self.http_server.user_list
self._room_list = self.http_server.room_list
self._private_messages = self.http_server.private_message_map
self._message_queue = self.http_server.message_queue
self._user_list.add_participant(self)
self.current_user = self._user_list.get_user(parasite)
was_offline = self.current_user['status'] == 'offline'
self._user_list.update_user_status(parasite, 'active')
self._user_list.update_user_last_active(self.current_user['id'])
self._broadcast_user_list()
self._send_room_list()
self._send_pm_thread_list()
if was_offline is True:
self._broadcast_alert(u'{} is online.'.format(
self.current_user['username']))
self._send_alert('Connection successful.')
log_from_server(
'debug', 'Client ({}:{}) connected successfully.'.format(
parasite, self.session.session_id))
# send queued messages
messages = self._message_queue.get_invitations(self.current_user['id'])
for message in messages:
self.send({
'type': message['type'],
'data': json.loads(message['content'])
})
log_from_server(
'debug', 'Sent client {} {} queued messages.'.format(
parasite, len(messages)))
def upload_to_s3(image_data, image_type, bucket):
s3_key = 'images/uploads/' + sha256(image_data).hexdigest()
try:
exists = filter(lambda x: x.key == s3_key, list(bucket.objects.all()))
log_from_server('info', 'Found object in S3: {}'.format(exists))
if len(exists) <= 0:
decoded_image = base64.decodestring(
image_data[image_data.find(',') + 1:])
# Do the actual upload to s3
bucket.put_object(Key=s3_key,
Body=decoded_image,
ContentEncoding='base64',
ContentType=image_type,
ACL='public-read')
return 'https://s3-us-west-2.amazonaws.com/best-ever-chat-image-cache/' + s3_key
except Exception as e:
log_from_server('debug', 'Exception during image upload: ' + e.message)
log_from_server(
'debug',
'Image failed to upload to S3 bucket: UPLOAD({}) KEY({})'.format(
image_type, s3_key))
return None
def retrieve_image_in_s3(image_url, bucket):
s3_key = 'images/' + sha256(image_url).hexdigest()
try:
exists = filter(lambda x: x.key == s3_key, list(bucket.objects.all()))
log_from_server('info', 'Found object in S3: {}'.format(exists))
if len(exists) <= 0:
req_for_image = get(image_url, stream=True)
file_object_from_req = req_for_image.raw
req_data = file_object_from_req.read()
if len(req_data) == 0:
raise Exception('empty data, response code:{}'.format(
req_for_image.status_code))
# Do the actual upload to s3
bucket.put_object(Key=s3_key, Body=req_data, ACL='public-read')
return 'https://s3-us-west-2.amazonaws.com/best-ever-chat-image-cache/' + s3_key
except Exception as e:
log_from_server('debug',
'Exception during image transfer: ' + e.message)
log_from_server(
'debug',
'Image failed to transfer to S3 bucket: URL({}) KEY({})'.format(
image_url, s3_key))
return image_url
from chat.message_queue import MessageQueue
from chat.new_chat_connection import new_chat_router
from chat.private_messages import PrivateMessageMap
from chat.rooms import RoomList
from chat.users import UserList
from emoji.emoji_curation import curated_emojis
logging.getLogger().setLevel(logging.DEBUG)
config_parser = SafeConfigParser()
current_dir = os.path.dirname(os.path.realpath(__file__))
with open('install/chat.cfg', 'r+') as cfg:
config_parser.readfp(cfg)
config_section = os.environ['BEC_ENV'] if os.environ.has_key('BEC_ENV') else 'local'
log_from_server('info', "Loading config: [{}]".format(config_section))
SECRET_KEY = config_parser.get(config_section, 'BEC_SECRET_KEY')
DB_USER = config_parser.get(config_section, 'BEC_DB_USER')
DB_PASSWORD = config_parser.get(config_section, 'BEC_DB_PASSWORD')
DB_HOST = config_parser.get(config_section, 'BEC_DB_HOST')
DB_SCHEMA = config_parser.get(config_section, 'BEC_DB_SCHEMA')
GITHUB_USERNAME = config_parser.get(config_section, 'GITHUB_USERNAME')
GITHUB_TOKEN = config_parser.get(config_section, 'GITHUB_TOKEN')
http_server = None
class Application(tornado.web.Application):
def __init__(self, handlers, settings):
super(Application, self).__init__(handlers, **settings)
def on_message(self, message):
json_message = json.loads(message)
if self.current_user['id'] != self.session.handler.get_secure_cookie(
'parasite'):
self._send_auth_fail()
message_type = json_message['type']
if message_type == 'client log':
log_from_client(json_message['level'], json_message['log'],
self.current_user['id'], self.session.session_id)
return
if json_message['user id'] != self.current_user['id']:
log_from_server(
'warning',
'Socket message received from incorrect parasite ({}) from socket ({}:{}). Sending authentication failure.'
.format(json_message['user id'], self.current_user['id'],
self.session.session_id))
self._send_auth_fail()
return
if message_type == 'chat message':
self._broadcast_chat_message(json_message['user id'],
json_message['message'],
json_message['room id'])
elif message_type == 'private message':
self._broadcast_private_message(json_message['recipient id'],
json_message['message'])
elif message_type == 'image':
destination_is_thread = json_message[
'room id'] in self._user_list.get_all_usernames()
# if the url doesn't look like an image, just send it as a normal chat
if not is_image_url(json_message['image url']):
if destination_is_thread:
self._broadcast_private_message(json_message['room id'],
json_message['image url'])
else:
self._broadcast_chat_message(json_message['user id'],
json_message['image url'],
json_message['room id'])
else:
image_src_url = retrieve_image_in_s3(json_message['image url'],
self._bucket)
self._broadcast_image(json_message['user id'], image_src_url,
json_message['room id'],
json_message['nsfw'],
json_message['image url'])
elif message_type == 'image upload':
image_url = upload_to_s3(json_message['image data'],
json_message['image type'], self._bucket)
if image_url is not None:
self._broadcast_image(json_message['user id'], image_url,
json_message['room id'],
json_message['nsfw'])
else:
self._send_alert('Failed to send uploaded image.', 'dismiss')
elif message_type == 'room action':
if json_message['action'] == 'create':
self._create_room(json_message['room name'])
elif json_message['action'] == 'delete':
self._delete_room(json_message['room id'])
elif json_message['action'] == 'join':
self._join_room(json_message['room id'],
json_message['accept'],
json_message['inviter id'])
elif json_message['action'] == 'leave':
self._leave_room(json_message['room id'])
elif json_message['action'] == 'invite':
self._send_invitations(json_message['user ids'],
json_message['room id'])
elif message_type == 'status':
self._user_list.update_user_status(self.current_user['id'],
json_message['status'])
self._broadcast_user_list()
elif message_type == 'typing':
self._user_list.update_user_typing_status(self.current_user['id'],
json_message['status'])
self._broadcast_user_list()
elif message_type == 'version':
if json_message['client version'] < CLIENT_VERSION:
self._send_alert(
'Your client is out of date. You\'d better refresh your page!',
'permanent')
elif json_message['client version'] > CLIENT_VERSION:
self._send_alert(
'How did you mess up a perfectly good client version number?',
'permanent')
elif message_type == 'settings':
self._update_settings(json_message['data'])
elif message_type == 'bug' or message_type == 'feature':
self._send_to_github(message_type, json_message['title'],
json_message['body'])
else:
print 'Received: ' + str(json_message)
def __init__(self, db):
log_from_server('info', 'Initializing user list...')
self.db = db
parasites = self.db.query("SELECT id FROM parasite")
for parasite in parasites:
self.load_user(parasite['id'])
def __init__(self, db, user_list):
log_from_server('info', 'Initializing message queue...')
self.db = db
self._user_list = user_list
