示例#1
0
class ChatServiceLiteHandler(tornado.web.RequestHandler):
    def initialize(self, config, auth):
        self.config = config
        self.auth_provider = auth
        self.persistent = PsycopgPersistentService(config)
        self.loader = tornado.template.Loader(os.path.join(rootdir, 'templates'))
        self.ctx = zmq.Context()
        self.push_sock = self.ctx.socket(zmq.PUSH)
        self.push_sock.connect(self.config.get('push_endpoint', 'tcp://127.0.0.1:60001'))

    def generate_(self, name = None, color = None, count = None):
        if name is None:
            name = urllib.parse.unquote(self.get_cookie('lite_chat_username', urllib.parse.quote('名無し')))
        if color is None:
            color = urllib.parse.unquote(self.get_cookie('lite_chat_color', urllib.parse.quote('black')));
        if count is None:
            try:
                count = int(self.get_cookie('lite_chat_count', '20'));
            except: pass
        messages = self.persistent.fetch_latest(count, None)
        for i in range(len(messages)):
            messages[i]['d'] = datetime.datetime.fromtimestamp(messages[i]['d'] / 1000).strftime('%m/%d %H:%M:%S')
            items = URL_RE.split(messages[i]['t'])
            for x in range(len(items)):
                if x % 2 == 0:
                    items[x] = (items[x], None)
                else:
                    items[x] = (urllib.parse.unquote_plus(items[x]), items[x])
            messages[i]['t'] = items
        self.finish(self.loader.load('lite.html').generate(messages = messages, name = name, color = color, count = str(count)))

    def get(self):
        self.generate_()

    def post(self):
        name = self.get_argument('name', '名無し')
        body = self.get_argument('body', None)
        color = self.get_argument('color', 'black')
        count = 20
        try:
            count = int(self.get_argument('count', '20'))
        except: pass

        self.set_cookie('lite_chat_username', urllib.parse.quote(name))
        self.set_cookie('lite_chat_color', urllib.parse.quote(color))
        self.set_cookie('lite_chat_count', str(count))

        if body is not None and len(body) > 0:
            dt = datetime.datetime.now(datetime.timezone.utc)
            msgid = self.persistent.store(self.current_user, dt, name, color, None, body)
            self.push_sock.send(b'chat\0' + json.dumps({
                'n': name, 'c': color, 't': body,
                'i': msgid, 'd': int((dt - UNIXTIME_ORIGIN).total_seconds() * 1000), 'g': None
            }).encode('utf-8'))
        self.redirect(urllib.parse.urlparse(self.request.headers.get('Referer', self.request.path)).path)

    def get_current_user(self):
        return self.auth_provider.get_user_id(self.request)
示例#2
0
 def initialize(self, config, auth):
     self.config = config
     self.auth_provider = auth
     self.persistent = PsycopgPersistentService(config)
     self.loader = tornado.template.Loader(os.path.join(rootdir, 'templates'))
     self.ctx = zmq.Context()
     self.push_sock = self.ctx.socket(zmq.PUSH)
     self.push_sock.connect(self.config.get('push_endpoint', 'tcp://127.0.0.1:60001'))
示例#3
0
class HashedImageHandler(tornado.web.RequestHandler):
    def initialize(self, config, auth):
        self.config = config
        self.auth_provider = auth
        self.persistent = PsycopgPersistentService(config)

    def get(self, image_hash):
        print(image_hash)
        binary, mime_type = self.persistent.fetch_icon(binascii.a2b_hex(image_hash.encode('ascii')))
        print(type(binary), mime_type)
        if not binary: raise tornado.web.HTTPError(404)
        self.set_header("Content-Type", mime_type)
        self.write(binary)
示例#4
0
 def initialize(self, config, auth):
     self.config = config
     self.auth_provider = auth
     self.persistent = PsycopgPersistentService(config)
示例#5
0
 def initialize(self, config, auth):
     self.config = config
     self.auth_provider = auth
     self.persistent = PsycopgPersistentService(config)
     self.authenticated_user_id = None
示例#6
0
class ChatServiceWebSocketHandler(tornado.websocket.WebSocketHandler):
    def initialize(self, config, auth):
        self.config = config
        self.auth_provider = auth
        self.persistent = PsycopgPersistentService(config)
        self.authenticated_user_id = None

    def open(self):
        print('[ws::open]', self.request.headers)
        self.ctx = zmq.Context()
        self.sub_sock = self.ctx.socket(zmq.SUB)
        self.sub_sock.connect(self.config.get('sub_endpoint', 'tcp://127.0.0.1:60000'))
        self.sub_sock.setsockopt(zmq.SUBSCRIBE, b'chat\0')
        self.strm = zmq.eventloop.zmqstream.ZMQStream(self.sub_sock)
        self.strm.on_recv(self.on_message_from_hub)
        self.push_sock = self.ctx.socket(zmq.PUSH)
        self.push_sock.connect(self.config.get('push_endpoint', 'tcp://127.0.0.1:60001'))

    def on_message(self, message):
        req = json.loads(message)

        if not self.authenticated_user_id:
            if req['m'] == 'auth':
                user_id = req['user-id']
                if not WebSocketAuth.verify_token(user_id, self.request, req['token']):
                    raise tornado.web.HTTPError(401)
                self.authenticated_user_id = user_id
            return

        if req['m'] == 'post':
            dt = datetime.datetime.now(datetime.timezone.utc)
            req['d'] = int((dt - UNIXTIME_ORIGIN).total_seconds() * 1000)
            icon_hash = None
            if 'g' in req and req['g']: icon_hash = binascii.a2b_hex(req['g'].encode('ascii'))
            print(req)
            msg_hash = self.compute_message_hash(req)
            # TODO: ハッシュ値を使った重複チェック
            uid = self.persistent.store(self.current_user, dt, req['n'], req['c'], icon_hash, req['t'])
            self.push_sock.send(b'chat\0' + json.dumps({
                'n': req['n'], 'c': req['c'], 't': req['t'],
                'i': uid, 'd': req['d'], 'g': req['g']
            }).encode('utf-8'))
            self.write_message(json.dumps({
                'e': req['e'],
                'r': 'ok'
            }))
        elif req['m'] == 'latest':
            if 'i' not in req: req['i'] = -1
            self.write_message(json.dumps({
                'e': req['e'],
                'r': 'ok',
                'm': self.persistent.fetch_latest(req['c'], req['i'])
            }))
        elif req['m'] == 'store-icon':
            icon_binary = binascii.a2b_base64(req['d'].encode('ascii'))
            icon_hash = hashlib.sha1(icon_binary).digest()
            icon_hash_hex = binascii.b2a_hex(icon_hash).decode('ascii')
            self.persistent.store_icon(self.current_user, icon_hash, icon_binary, req['t'], '')
            self.write_message(json.dumps({
                'e': req['e'],
                'r': 'ok',
                'h': icon_hash_hex
            }))
        elif req['m'] == 'ping':
            self.write_message(json.dumps({
                'e': req['e'],
                'r': 'ok'
            }))
        else:
            print('unknown:', req)

    def on_message_from_hub(self, messages):
        if not self.authenticated_user_id: return
        for msg in messages:
            obj = json.loads(msg[5:].decode('utf-8'))
            self.write_message(json.dumps({
                'm': 'strm',
                'd': obj
            }))

    def on_close(self):
        print('[ws::close]')
        self.strm.close()
        self.sub_sock.close()
        self.push_sock.close()

    def compute_message_hash(self, obj):
        txt = self.current_user + "\0" + obj['r'] + "\0" + obj['n'] + "\0" + obj['c'] + "\0" + obj['t'];
        sha1 = hashlib.sha1()
        sha1.update(txt.encode('utf-8'))
        return sha1.digest()

    def get_current_user(self):
        # TODO: ChromiumがWebSocketのBasic認証に対応したら指定されたauth_providerを利用する
        if not self.authenticated_user_id:
            raise tornado.web.HTTPError(401)
        return self.authenticated_user_id