During 2008′s Google Summer of Code I introduced a new storage abstraction layer to the MoinMoin wiki engine. This allows you to run moin on a variety of backends (filesystem, mercurial, etc.).

This year (2009) I participated again. My application contained three major areas of work:

• Reintroducing ACLs for the storage branch.
• Adding fairly advanced ‘routing’ configuration capabilities for your storage backend(s).
• Adding a SQLAlchemy backend which, in theory, should support a variety of RDBMS.

The first two objectives were finished quite well. Two different pieces of middleware were introduced for both, the ACLs and the routing. You can now use several different backends in a simple or optionally fairly complex way. You could just use one single filesystem backend or potentially hundreds of different backends, each with different ACLs applied, and mount each one into its own namespace (you may be familiar with this concept from UNIX, where you can mount discs and such into arbitrary places of the filesystem tree).

In addition to that, ACLs have been refactored. ‘revert’ and ‘delete’ were removed (obviously you will still be able to perform the corresponding actions from the UI), ‘create’ and ‘destroy’ were added.

As for the SQLAlchemy backend, we do have a somewhat working version. Unfortunately it still suffers from severe performance problems. Originally I wanted to fix that after SoC, but real-life (bachelor’s thesis, etc.) caught me, so I will have to postpone that. If you have some SQLAlchemy experience and want to help out here (or with something else), you are very welcome to join us (#moin-dev on irc.freenode.net).

For an overview of what else has been done during GSoC 2009 on the storage side of things, take a look at the following resources:

• http://moinmo.in/Storage2009
• http://hg.moinmo.in/moin/2.0-storage/

Please keep in mind that this is still fairly alpha. Especially the UI is for developers and geeks only and will be redone properly (with Jinja2) before the release (help needed here as well).

Thanks to the whole moin crew and especially my mentor Thomas Waldmann for the nice and fun collaboration!

(Oh and – hopefully – hello planet python!)

As I already mentioned in my last posting I participated in this years Google Summer of Code. I sent an application for the MoinMoin Wiki Project and got elected as one of the students who were allowed to work on MoinMoin over the summer. My task was to Extend and refactor the MoinMoin Storage Engine.

Historically, MoinMoin has always stored everything as text files on the disk. There are several disadvantages to this old approach:

• Due to the way the files were stored, the storage didn’t scale well.
• It is almost impossible to have separate dedicated “database” servers.
• Pages, users and attachments weren’t stored uniformly, thus making the system more complex.

The idea of my task (not the first of its kind) was to inject an abstracted storage layer. MoinMoin now talks to some object it knows is a storage backend and does not care how the backend handles storage technically. The things you store inside backends are called items which have revisions. Pages, users and attachments are now uniformly stored as or inside such items. MoinMoin just says “store this item” and the backend does, depending on what kind of backend it is.

The administrator defines what backends to use for user and data storage. You can choose between several backends, e.g. a Mercurial backend (which was another GSoC task) or a filesystem backend (still useful if you don’t have a database). It is not difficult to write a new backend since all you need to do is implement a single class (The new API was designed for that). There are some other (still unfinished) backends that can be used as middleware, e.g. a backend that wraps other backends and stores items in the correct backend depending on the name of the item. There is also a converter script that takes a source and a target backend and transfers all the data from the source to the target backend. This is especially useful in combination with the read-only FS17 backend. As the name indicates, this backend supports reading data from your “old” MoinMoin 1.7 installations. This allows you to migrate to the new storage system and swap backends easily afterwards in case your requirements change. The sheer amount of backends I just mentioned should be proof enough that it is not hard to write a new backend, especially since there are even more backends in existence. As a side note: These changes make it possible to come up with a SQL or even a SQLAlchemy backend. (The benefit of the latter is to be database-agnostic.)

Note, however, that this will not make it into MoinMoin 1.8. There is still work that needs to be done. If you want to help or even contribute a backend, join #moin-dev on Freenode and we will help you get started.

It was fun to participate. The other developers were friendly and welcoming, which is essential in an Open Source environment. So thanks Thomas, Alexander, Reimar, Radomir and Armin! I especially need to thank Johannes for being a fantastic mentor (no objections)! I learned a lot from all of you. So thanks a bunch for allowing me to work on your project and thanks Google for driving the Summer of Code!