Ok, so first set up your virtualenv you can check how to do that on my last post if you don’t know (just follow it up to the “source sys/bin/activate”) command.

Now there are two ways to install repoze.bfg, the first one is:

easy_install -i http://dist.repoze.org/bfg/1.2/simple repoze.bfg.jinja2

and the second one is to install it from pypi which is almost the same:

easy_install repoze.bfg.jinja2

Cool isn’t it?

Now to create your repoze.bfg app use paster like this:

paster create -t bfg_jinja2_starter bfgapp

And set it up as a development egg

cd bfgapp
jython setup.py devel

You can test it if you want, running

paster serve bfgapp.ini

And that’s it!! Much easier isn’t it?

Now, let’s look how to put this inside our java webapp, for this we are going to use a WSGI java servlet which is included with jython, it’s called modjy.

First of all copy the jython.jar file inside your WEB-INF/lib directory.

Next add the servlet to your WEB-INF/web.xml file, here is my example web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
    <display-name>BFGApp</display-name>
    <servlet>
        <servlet-name>modjy</servlet-name>
        <servlet-class>com.xhaus.modjy.ModjyJServlet</servlet-class>
        <init-param>
            <param-name>python.home</param-name>
            <param-value>/home/iamedu/BFG/sys</param-value>
        </init-param>
        <init-param>
            <param-name>cache_callables</param-name>
            <param-value>1</param-value>
        </init-param>
        <init-param>
            <param-name>reload_on_mod</param-name>
            <param-value>1</param-value>
        </init-param>
        <init-param>
            <param-name>log_level</param-name>
            <param-value>debug</param-value>
        </init-param>
        <init-param>
            <param-name>load_site_packages</param-name>
            <param-value>1</param-value>
        </init-param>
        <init-param>
            <param-name>python.executable</param-name>
            <param-value>/home/iamedu/BFG/sys/bin/jython</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet>
        <servlet-name>DefaultServlet</servlet-name>
        <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
        <init-param>
            <param-name>listings</param-name>
            <param-value>true</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>modjy</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>DefaultServlet</servlet-name>
        <url-pattern>/static/*</url-pattern>
    </servlet-mapping>
    <session-config>
        <session-timeout>
            30
        </session-timeout>
    </session-config>
</web-app>

Here there are two important initial parameters for the modjy servlet:

• python.home This one should point to your virtualenv
• python.executable This one should point to your virtualenv’s jython executable

You can see I also defined a “default” servlet, this is because there’s a problem with the modjy servlet managing static resources, and it’s probably faster to manage them directly with the default servlet.

Now to make the static resources accessible to the default servlet, just copy them from the templates/static directory in your BFG app to the web directory inside your java webapp, just copy the default.css file and the images directory don’t copy the whole static directory, unless you want to change your links to something like: “static/static/default.css”

Now we just need to add the wrapper between the modjy servlet and bfg, this is quite easy, create an application.py file inside your web directory with the following contents:

import site
from repoze.bfg.paster import get_app
 
handler = get_app('/home/iamedu/BFG/MyProject/MyProject.ini', 'main')

And now deploy your app and voila!, you have repoze.bfg on you favorite servlet container, you can call your java classes from bfg as it is running in the same Java VM.

We use import site, because the modjy servlet doesn’t load site-packages automatically, and it’s probably a bad idea to write the complete path in the get_app, you should copy it to your webapp’s web directory and get the current work directory.

If you want to package your bfg app inside your java webapp you can copy it to the web directory, everything inside that directory is also in your pythonpath.

Hope this helps somebody!

There must be a lot of java guys who think the same and there are projects like Groovy and Grails endorsed by Sun,  I was impressed to see even a Ruby container in glassfish v3.

I haven’t tried ruby yet so I cannot comment on that, and I wanted to try something simple with jython so I decided to try bfg, my first attempts didn’t work so I asked for help on the bfg developers list, and a loooot of help from Chris McDonough I got it working.

It isn’t soo nice yet, and zcml configuration doesn’t work but at least it’s usable.

Here is how to get it working, since some changes were just made by Chris on the development’s trunk you need subversion and mercurial to get the repos.

First of all get jython I tried this with 2.5.1, it is pretty simple to install it.

Next you need to get setuptools, you can get that from pypi make sure to download the source version (the one that ends with .tar.bz2)

To install it uncompress it, get into the directory and run:

${JYTHONDIR}/bin/jython setup.py install

Since we are going to be testing a lot it’s better to install virtualenv do it with

${JYTHONDIR}/bin/easy_install virtualenv

Now create a folder where you can start working, in this case I’ll assume it’s called BFG

Get into the BFG folder and create a virtual env.

cd BFG
${JYTHONDIR}/bin/virtualenv --no-site-packages sys
source sys/bin/activate

After this you’ll have you virtualenv’s jython and easy_install in your path.

It’s time to download latest versions from repos, and also http://pypi.python.org/packages/source/z/zope.schema/zope.schema-3.5.4.tar.gz this from pypi

svn co http://svn.repoze.org/repoze.bfg/trunk/ repoze.bfg
svn co http://svn.repoze.org/repoze.bfg.jinja2/trunk/ repoze.bfg.jinja2
hg clone http://dev.pocoo.org/hg/jinja2-main jinja2
tar xfvj zope.schema-3.5.4.tar.gz

Now we need to change a few things head into the zope.schema-3.5.4 folder and edit this file src/zope/schema/_bootstrapfields.py

In line 31 you should see something like:

class ValidatedProperty(object):
 
    def __init__(self, name, check=None):
        self._info = name, check
 
    def __set__(self, inst, value):
        name, check = self._info
        if value != inst.missing_value:
            if check is not None:
                check(inst, value)
            else:
                inst.validate(value)
        inst.__dict__[name] = value

Add a __get__ method like this:

class ValidatedProperty(object):
 
    def __init__(self, name, check=None):
        self._info = name, check
 
    def __set__(self, inst, value):
        name, check = self._info
        if value != inst.missing_value:
            if check is not None:
                check(inst, value)
            else:
                inst.validate(value)
        inst.__dict__[name] = value
    def __get__(self, inst, owner):
        name, check = self._info
        return inst.__dict__[name]

Now install zope.schema with:

jython setup.py install

Now get into the jinja2 directory, here you should patch your file with the patch provided below

patch -p1 < jinja2_jython.patch

Now for install jinja2, repoze.bfg and repoze.bfg.jinja2 in that order, for each package just go into the directory and run:

${JYTHONDIR}/bin/jython setup.py install

You can create a project with paster now, but it won’t work right away, because zcml doesn’t work with jython but you can get it working.

Here is a sample project tweaked to work, just download it and run:

paster serve MyProject.ini

I hope this works for you and that you find it useful

MyProject-jython.tar

jinja2_jython.patch

UPDATE Chris just told me that zope.schema now passes tests under jython, so it’s no longer necesarry to change the _bootstrapfields.py file.

Another thing, I forgot to mention that you need to run jython setup.py develop with the MyProject egg.

For my thesis project I’m designing an embedded system along with some friends, it is designed for the ARM architecture. It’s going pretty well, we have an ARM  simulator, some code and ideas for a microkernel (mostly taken from the Fiasco microkernel), and a basic hardware platform.  This is what I really  really like, but… I need a lot more experience to build high quality things… so the question is… what to do the next few years?

So it’s natural that I’m curious about what is going to happen in the near future…

I think that we are going to see more portable devices which run UNIX systems, like iPhone OS and Android, I think there are two main reasons why this will continue to happen.

• UNIX is a very well known and tested architecture.
• LINUX has been ported to nearly every machine architecture, because it’s Open Source.

But that is not the only thing, prices on computer processors are dropping so.. I think we are going to embed a computer on everything we can, or wouldn’t you like your internet fridge to order food from the supermarket when it knows you’re running low on something. Or imagine if you could get updates for your microwave, so it knew how long it takes to defrost some kind of meat (ok this one is very stupid). Your car could connect to google maps to show you the best route to get home.

And what if you could accomplish all of this with the same technology that drives your phone? Why not? a simple ARM processor costs about 15 dollars! (ARM is important here because it’s an open standard which the iPhone, Motorola DEXT and many others happen to use).

The problem with all of this? we need to train a ton of new programmers to create apps for your iPhone, your DEXT, your microwave, your fridge, your car, your firefly, your TV….. blah blah blah blah.

Well… it won’t be that bad… all of that runs on UNIX doesn’t it? Well, I think we could get most programmers to do stuff for our gadgets.. how?

Ok this may sound stupid and it probably is… but what about HTML?

At least for the GUI based gadgets it would be nice… we have tons of  web programmers, we could bring them to the desktop and beyond, and HTML 5 is the key.

HTML 5 has databases, and interaction it is seen as a replacement for Google Gears, and XUL, and I think it can be seen as a direct competitor for Java’s SWING, Adobe’s AIR…

And think about it, part of the HTML 5 standard is how things are displayed on mobile devices.

With this we are leaving all processing in the cloud, we don’t need the fastest processors.. at least not for the front ends, at least just in theory we need just a web browser (and whatever is needed to run a web browser). Sounds like Chrome OS doesn’t it?

The interesting is that we can build our standard java/python/php/whatever backend, or in the case of your microwave you can interact with your C program that drives the motor….

I don’t really believe all of this, but it would be really nice… don’t you think?