def open(self):
        print "WebSocket opened", "x" * 20
        self.mongodb = self.application.settings['_db']
        user = self.user
        exchange = self.session['exchange']

        messages = [
            msg.content
            for msg in BoardMessage.find_all(id=self.session.session_id)
        ]
        if len(messages) > 0:
            self.write_message(json.dumps(messages["message-list"]))

        session = self.mongodb.board.find_one({"id": self.session.session_id})

        self.mongoSession = session
        self.messagesBuffer = messages
        binding_keys = (self.session['public_key'],
                        self.session['private_key'])
        print "QUEUE NAME", session['queue']
        self.channel = PersistentChannel(self.application.channel,
                                         str(session['queue']),
                                         exchange,
                                         binding_keys,
                                         self,
                                         arguments={"x-expires": int(600000)})
        self.channel.add_message_action(self.message_call_back, None)
        self.channel.connect()
        self.lastestTimestamp = 0
        self._isClosed = False
    def post(self):
        self.mongodb = self.application.settings['_db']
        user = self.user
        timestamp = int(self.get_argument('timestamp'))
        exchange = self.session['exchange']
        self.clean_matured_message(timestamp)
        messages = [ msg['content'] for msg in BoardMessage.get_collection().find(\
           {
           "id":self.session.session_id,
           "timestamp":{"$gt":timestamp}
           },
          sort=[("timestamp",1)]
           )]

        session = self.mongodb.board.find_one({"id": self.session.session_id})

        if len(messages) > 0:
            self.finish(json.dumps(messages))
            return
        else:
            print "Nothing in DB", timestamp, self.user.username

        binding_keys = [
            self.session['public_key'], self.session['private_key']
        ]
        if self.user.isBot:
            binding_keys.append(self.session['bot_key'])

        self.channel = PersistentChannel(self.application.channel,
                                         str(session['queue']),
                                         exchange,
                                         binding_keys,
                                         self,
                                         arguments={"x-expires": int(600000)})
        self.channel.add_message_action(self.message_call_back, None)
        self.channel.connect()
        self.closed = False
    def post(self):
        message = None
        user = self.user
        room_id = self.get_argument('room_id')
        room = Room.find(_id=room_id)
        if not room:
            print Room.find_all()
            print "not a valid room", room_id
            self.finish()
            return

        self.mongodb = self.application.settings['_db']
        msg = {"id": self.session.session_id, "room_id": room.id}

        BoardMessage.get_collection().remove({
            "id": self.session.session_id,
        },
                                             safe=True)

        # guarantee only one exist
        self.mongodb.board.update({"id": self.session.session_id},
                                  msg,
                                  upsert=True)

        exchange = str(room.exchange)

        self.session['exchange'] = exchange

        public_key = ('broadcast_%s_%s.testing') % (exchange, room._id)
        private_key = ('direct.%s.%s.%s') % (exchange, room._id, user._id)
        binding_keys = [public_key, private_key]
        if user.isBot:
            bot_key = ('direct.%s.%s.bot') % (exchange, room._id)
            binding_keys.append(bot_key)
            self.session['bot_key'] = bot_key

        message = {
            'method': 'enter',
            'user_id': user.id,
            'room_id': room.id,
            'private_key': private_key
        }

        arguments = {'routing_key': 'dealer', 'message': message}
        self.broadcast_channel = broadcast_channel = PersistentChannel(
            self.application.channel,
            "%s%s" % (str(self.session.session_id), room.id[-10:]),
            exchange,
            binding_keys,
            declare_queue_only=True,
            arguments={"x-expires": int(600000)})

        self.callBackCount = 0
        broadcast_channel.add_ready_action(self.initial_call_back, arguments)
        broadcast_channel.connect()

        self.channel = Channel(self.application.channel, exchange)

        self.channel.add_ready_action(self.initial_call_back, arguments)
        self.channel.connect()
        self.session['public_key'] = public_key
        self.session['private_key'] = private_key
        #self.session['messages']	= list()
        print "ENTER!"