d2m

Create a file ‘jsonrpc_application.py‘, the bobo backend application:

import bobo

I use lovely.jsonrpc for the JSON-RPC server implementation.

from lovely.jsonrpc.dispatcher import JSONRPCDispatcher

The PyjamasAPI class follows the JSONRPCExample that comes with the Pyjamas distibution. You may want to put your own remote API in here.

class PyjamasAPI(object):
    def echo(self, txt):
        return txt
    def reverse(self, txt):
        return txt[::-1]
    def uppercase(self, txt):
        return txt.upper()
    def lowercase(self, txt):
        return txt.lower()

Now create the jsonrpc dispatcher based on the provided API.

dispatcher = JSONRPCDispatcher(PyjamasAPI())

The next part is all that is needed to make the ‘bobo’ application process JSON-RPC calls.

Define a route, e.g. ‘/jsonrpc’ as the the service endpoint, configure it to return ‘application/json’ and let the dispatcher dispatch the request body. A check for the content type is necessary to get at the correct data from the WebOb request object. Pyjamas e.g. posts the JSON data in ‘x-www-form-urlencoded’ form.

@bobo.post('/jsonrpc', content_type='application/json')
def dispatch(bobo_request):
    content_type = bobo_request.headers['Content-Type']
    if content_type.startswith('application/x-www-form-urlencoded'):
        body = bobo_request.POST.items()[0][0]
    else:
        body = bobo_request.body
    return dispatcher.dispatch(body)

Thats all on the backend side.

In Pyjamas modify ‘examples/jsonrpc/JSONRPCExample.py’ and build it:

class EchoServicePython(JSONProxy):
    def __init__(self):
        JSONProxy.__init__(self, "http://localhost:8080/jsonrpc", \
        ["echo", "reverse", "uppercase", "lowercase"])

At last startup bobo. It is necessary to serve the JSONRPCExample from the bobo application (same domain) like static content:

$ bin/bobo -f jsonrpc_application.py \
           -s /demo=/path/to/examples/jsonrpc/output/

Now point your browser to

$ firefox http://localhost:8080/demo/JSONRPCExample.html

and run the example.

I hope you liked the walktrough. Btw, if you use the Google AppEngine template from my recent blogpost you can run the example almost unmodified from GAE too.

This post is part of a series of postings about more or less basic Grok apps that are ported from other python web frameworks. Motivation is that you can look at the original source and the grok code side-by-side and deduce from both. Source is available from svn.zope.org/grokapps/gbedemosite/.

This “demosite application” shows how to install multiple Grok applications and make them available from a single Grok instance (using ZEO and Apache). A test instance is available at gbe.d2m.at.

Review

Now that you have a few working Grok apps (Grok-By-Example), how about serving them all together from a single Grok instance?

Setup multiple applications for your demosite
One possible setup is to create the demosite as a Grok app on its own. You just construct the basic app layout (or let grokproject do it for you or simply checkout the ‘gbedemosite’ application). I strongly recommend to run your development from inside a virtualenv:

    $ svn co svn://svn.zope.org/repos/main/grokapps/gbedemosite
    $ cd gbedemosite
    $ virtualenv --no-site-packages .
    $ source bin/activate

You then apply the necessary changes for a multi-app setup. Lets start with ’setup.py’. Add the package name of the apps you want to run to the ‘install-requires’ section:

    install_requires=[...
                      'gbeguestbook',
                      'gbe99bottles',
                      'gbewiki',
                      'gbepastebin',
                      ...
                     ],

Now checkout the packages from SVN to your ‘gbedemosite’ folder. If the packages where available from PyPI or another package repository you could just skip this and the next step, buildout would fetch and install the packages on the next run:

    svn co svn://svn.zope.org/repos/main/grokapps/gbeguestbook
    svn co svn://svn.zope.org/repos/main/grokapps/gbe99bottles
    svn co svn://svn.zope.org/repos/main/grokapps/gbewiki
    svn co svn://svn.zope.org/repos/main/grokapps/gbepastebin

In ‘buildout.cfg’ add the same packages to ‘develop’:

    [buildout]
    develop = . gbeguestbook gbe99bottles gbewiki gbepastebin

Run bootstrap (if you have not already) and buildout:

    $ bin/python bootstrap.py
    $ bin/buildout

That’s all for now, lets move on to create the ‘gbedemosite’ app itself.

Create the ‘demosite’ application
You basically only need to change the ‘app.py’ template file. Lets assume you created the app by running “grokproject Demosite”, you already have a ‘Demosite’ application class, with an Index view and the associated ‘app_templates/index.pt’ template file.

You now want to setup all available example apps automatically when creating an instance of the demosite application. Adding an event subscription handler for the ‘Demosite’ class does just that:

    @grok.subscribe(Demosite, grok.IObjectAddedEvent)
    def handle(obj, event):
        applications=(('gbeguestbook.app.Application','Guestbook'),
                      ('gbe99bottles.app.Song','Song'),
                      ('gbewiki.app.WikiPage','Wiki'),
                      ('gbepastebin.app.Application','Pastebin'),
                      )
        for application, name in applications:
            app = zope.component.getUtility(grok.interfaces.IApplication,
                                            name=application)
            try:
                obj[name] = app()
            except DuplicationError:
                pass

The ‘applications’ list defines the example apps and their instance names. Whenever you create a new instance of your ‘Demosite’ class the example apps will be created with their fixed names inside it.

Make your demosite ready for public
If you want to serve your apps to the public, your site also should provide a ‘robots.txt’ file for the webcrawlers.

Add another grok.View to your application class and give it the name ‘robots.txt’:

    class Robots(grok.View):
        grok.name('robots.txt')

Then create another template file in ‘app_templates/robots.pt’. The template could be empty or hold instructions following the robots exclusion standard.

Next create a virtual host to serve the demosite from behind Apache:

    <VirtualHost *>
    ServerName    your.server.name
    ...
    RewriteEngine On
    RewriteRule ^/(.*)  http://127.0.0.1:8080/<demosite>/++vh++http:your.server.name:80/++/$1 [P,L]
    </VirtualHost>

(with <demosite> having the name of your public demosite instance). This should make your apps available at root level. Your ‘app_templates/index.pt’ template already holds links to all installed example apps and serves as default page for the Grok instance. If you need to access the ‘admin’ screens again point your browser to:

    http://localhost:8080/applications

Enable ZEO
Finally you want to debug the running demosite. Some of the example apps have no means to delete existing objects - but you can simply delete objects from the debugger too.

Debugging a running zope instance needs a change in the server setup: you create a ZEO server that holds the ZODB (Data.fs) and 2 ZEO clients that access their data from the ZEO server. One client (’zopectl’) will serve the Demosite application, the other client (’instance2′) will be used for debugging.

You need to change ‘buildout.cfg’, add and modify parts:

    [buildout]
    ...
    parts = ... zodb server instance2

    [zodb]
    recipe = zc.recipe.egg:script
    eggs = ZODB3

    [server]
    recipe = zc.zodbrecipes:server
    zeo.conf =
       <zeo>
          address 8100
       </zeo>
       <filestorage 1>
          path ${buildout:parts-directory}/data/ZEOData.fs
       </filestorage>

    [zopectl]
    recipe = zc.zope3recipes:instance
    application = app
    address = 8080
    zope.conf = devmode on
        <zodb>
          <zeoclient>
            server 8100
          </zeoclient>
        </zodb>
        site-definition ${buildout:parts-directory}/app/site.zcml

        <accesslog>
          <logfile>
            path ${buildout:parts-directory}/zopectl/access.log
          </logfile>
        </accesslog>

        <eventlog>
          <logfile>
            formatter zope.exceptions.log.Formatter
            path STDOUT
          </logfile>
        </eventlog>

    [instance2]
    recipe = zc.zope3recipes:instance
    extends = zopectl
    address = 9080

Finally
Run buildout again, run the tests, start the server, start the client:

    $ bin/buildout
    $ bin/test
    $ bin/server start
    $ bin/zopectl fg

Setup apache:

    $ sudo a2ensite your-vhost-id
    $ sudo /etc/init.d/apache2 restart

Access the demosite admin screens, create a ‘demosite’ instance and use it:

    http://your.server.name/applications

Hope that gets you up and running in record time - creating the demosite application was done in an hour. As always writing the docs took a bit longer ;)