Twisted Tornado Couchbase Aync Operation Demo

twisted-tornado-cb.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

#!/usr/bin/env python
#
# Copyright 2009 Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.

from datetime import datetime
import os.path
import json
import tornado.auth
import tornado.httpserver
import tornado.ioloop
import tornado.options
import tornado.web

import tornado.platform.twisted
tornado.platform.twisted.install()
from twisted.internet import reactor

# for 1.2.0
from couchbase import experimental
experimental.enable()
from txcouchbase.connection import Connection as TxCouchbase

from tornado.options import define, options

define("port", default=8888, help="run on the given port", type=int)


class Application(tornado.web.Application):

    def __init__(self):
        handlers = [
            (r"/", GetHandler),
            (r"/set", SetHandler),
            (r"/query", QueryHandler),
            (r"/fetch", FetchHandler),
        ]
        settings = dict(
            blog_title=u"Tornado Blog",
            template_path=os.path.join(os.path.dirname(__file__), "templates"),
            static_path=os.path.join(os.path.dirname(__file__), "static"),
            xsrf_cookies=True,
            cookie_secret="__TODO:_GENERATE_YOUR_OWN_RANDOM_VALUE_HERE__",
            debug=True,
        )
        tornado.web.Application.__init__(self, handlers, **settings)

        # Have one global connection to the blog DB across all handlers
        self.cb = TxCouchbase(bucket='beer-sample')


class SetHandler(tornado.web.RequestHandler):
    # def get(self):
    #    self.write("Hello, world")

    @tornado.web.asynchronous
    def get(self):
        k = self.get_argument('k', 'key')
        self.application.cb.set(k, str(datetime.now())).addCallback(self.on_set)
        print datetime.now(), 'set done'

    def on_set(self, ret):
        print datetime.now(), "Set key. Result", ret
        self.write(str(datetime.now()) + ":" + str(ret.key))
        self.finish()


class GetHandler(tornado.web.RequestHandler):
    # def get(self):
    #    self.write("Hello, world")

    @tornado.web.asynchronous
    def get(self):
        k = self.get_argument('k', 'key')
        self.application.cb.get(k).addCallback(self.on_get)
        print datetime.now(), 'get done'

    def on_get(self, ret):
        print datetime.now(), "Got key. Result", ret
        self.write(str(datetime.now()) + ":" + ret.value)
        self.finish()


class QueryHandler(tornado.web.RequestHandler):
    # def get(self):
    #    self.write("Hello, world")

    @tornado.web.asynchronous
    def get(self):
        """
        include_docs=True does not support in async view.
        """
        d = self.application.cb.queryAll("beer", "brewery_beers", limit=20)
        d.addCallback(self.on_get)
        d.addErrback(self.on_error)
        print datetime.now(), 'get done'

    def on_get(self, ret):
        print datetime.now(), "Query. Result", ret
        for row in ret:
            self.write("Got row {0} <br />".format(row.key))
        self.finish()
    
    def on_error(self, err):
        err = err.value.objextra
        print err
        print err.url
        self.write(err.value)
        self.finish()


class FetchHandler(tornado.web.RequestHandler):
    # def get(self):
    #    self.write("Hello, world")

    @tornado.web.asynchronous
    def get(self):
        """
        include_docs=True does not support in async view.
        so it has to get it in another round
        """
        d = self.application.cb.queryAll("beer", "brewery_beers", limit=20)
        d.addCallback(self.on_get)
        d.addErrback(self.on_error)
        print datetime.now(), 'get done'

    def on_get(self, ret):
        print datetime.now(), "Query. Result", ret
        keys = []
        for row in ret:
            keys.extend(row.key)
        print 'keys: ', len(keys)
        d = self.application.cb.getMulti(keys)
        d.addCallback(self.on_getDocs)
        d.addErrback(self.on_error)
    
    def on_getDocs(self, ret):
        #print ret
        docs = {}
        for row in ret:
            row = ret[row]
            docs[row.key] = row.value
        self.write(docs)
        self.finish()

    def on_error(self, error):
        print error
        err = error.value
        if hasattr(err, 'objextra'):
            err = err.objextra
        print 'error:', err
        if hasattr(err, 'value'):
            self.write(err.value)
        else:
            self.write(str(err))
        self.finish()


def main():
    tornado.options.parse_command_line()
    application = Application()
    http_server = tornado.httpserver.HTTPServer(application)
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.instance().start()

if __name__ == "__main__":
    main()