The AC_CHECK_PYTHON_MODULE macro takes two arguments: The module name and optionally the variable name holding version information. This way it is not only possible to determine whether a module is installed (ie. loads in Python) on the current system, but also retrieve version information from that module.

The following examples checks whether the Crypto module is installed and retrieves its version information from Crypto.__version__:

AC_CHECK_PYTHON_MODULE(Crypto, __version__)

The macro itself does never report and error, but rather only a found/not found result. Error checking is up to the user and can be done via these two Autoconf variables:

• PYTHON_<MODULE_NAME>
• PYTHON_<MODULE_NAME>_VERSION

PYTHON_<MODULE_NAME> is set to “1″ if the module is present and “0″ if not present.
PYTHON_<MODULE_NAME>_VERSION is only set when the version variable argument has been set and contains the version information of the module, if the module been found. If the module is not present this variable is also set to “0″.

The version variable argument is optional as I wrote, so the following invocation works too and only checks whether the distutils module is present:

AC_CHECK_PYTHON_MODULE(distutils)

As I wrote earlier in this article I would like to share this macro with you. You can download it here.

For those of you who are now wondering what nwu is or could be, I did write about nwu on this weblog already and the ‘nwu – an introduction’ post should give you a good idea of what it is.

So, what has changed recently? Basically I merged my changes back into trunk, which means that most of these things are going to be used now. This means that the application framework, the scheduler, the APT “Packages” file parser, support for gzip compression in both the SecureXMLRPC client and server and the brand-new RPC framework are either already being used, or are going to be used soon.

Except for the RPC framework, which would need to be adapted, and the application framework, which depends on nwu.common.config, all these pieces of code also work stand-alone and can be used in other python applications too.

This article is going to explain the stand-alone nwu.common.* modules and their function.

nwu.common.SecureXMLRPC

I would like to start out introducing my “baby”: SecureXMLRPC. As the name suggests it provides support for XML-RPC over https. You might think “but that’s present in Python’s SimpleXMLRPCServer and xmlrpclib already” and you are right about that. However, the Python implementation uses OpenSSL, whilst SecureXMLRPC provides both a server and client implementation using GnuTLS. Even though the OpenSSL version works perfectly fine you cannot link it to GPL-licensed code due to the OpenSSL license being incompatible to the GPL.
Furthermore SecureXMLRPC supports compression of the XML-RPC payload and as of today is aware of multi-threading.

nwu.common.config

The config module provides a single class, “Config”. It basically is a slightly improved version of Python’s SafeConfigParser class and allows passing a “default value” argument to its get() method which is returned in case the setting is not present in the config.

nwu.common.app

This is a simple application framework. It makes use of “nwu.common.config” for reading the config file. However, its main feature is a simple-to-use command-line parser, which parses not only arguments from the command-line (such as –do-something, -d or –configfile=filename), but also supports “commands” as they can be found in several applications, such as aptitude. This way it is easy to not only create top-level commands (like “aptitude search <package name>”), but also nested command structures (like “program computer get <computer name>”, “program computer list“, etc.).

nwu.common.certtool

The certtool module is a wrapper around GnuTLS’ certtool application. It allows you to create private keys, certificate authorities, sign certificates, created certificate-signing-requests (CSRs)  and sign such.
However, please note that it currently does not implement the full functionality certtool provides but rather only the pieces nwu needs.

nwu.common.aptmethod

nwu.common.aptmethod simplifies implementation of an APT transport/method in Python. It takes care of all communication done with apt itself and thus gives you the opportunity to implement a new method in a simple way.

nwu.common.apt

Finally there is also the apt module. This module currently contains code to parse APT Packages files.

nwu.common.scheduler

One of the latest additions to the common module. It provides a way of scheduling tasks for execution at a certain date/time and executing a task in a given interval.

Network wide updates, or nwu, is a free software package licensed under the GPL (version 3 or later). It allows an administrator to remotely install software on and roll out security upgrades to managed computers. It is targeted at GNU/Linux systems using the Advanced Packaging Tool (APT) for package management and thus should run fine on all GNU/Linux distributions based on Debian GNU/Linux (such as gNewSense and all Ubuntu flavors).

It further gathers data about all managed computers in a database, which gives the administrator an overview about which systems are managed, the hardware configurations they have, the software installed on them and pending security updates.

The system is split into two major components: the server, which is the central management point, and the clients, usually referred to as agents, which report to the server.

Now let’s go into nasty technical details. nwu is implemented in Python, using XML-RPC and python-gnutls (and this way the GnuTLS library) for secure communication between the server and its agents. It further makes use of X.509-certificate authentication and provides an integrated CA-system which simplifies use of this method a great deal.

Currently nwu is in an alpha development stage, but moving forward quite fast. We are expecting to be able to release a stable version quite soon.

The development team is made up of Yves Junqueira and myself right now, but we would be happy to accept contributions from others.

If you are interested in nwu development you should probably watch this blog, as I am going to write about recent developments here.