There's a lot of complicated approaches for high availability servicesin general. Fortunately, NFS's statelessness makes it easy to do arelatively simple, low-rent version of this.

First, make your fileserver names point to virtual IP addresses. Embodythese virtual IPs on the physical machines of your choice that have someform of shared storage. To fail over a (virtual) fileserver, take downthe IP address on the original machine, unshare and unmount everything,mount and share it on the new machine

When discussions of ZFS on Linux (for real, as more than a user-levelfilesystem) come up, the usual issue that gets brought up is thelicensing problem; Sun's CDDL is incompatible with the kernel's GPLrequirement. But Sun could always change that if they wanted to, and Ithink there's another, more serious problem.

To put it simply, my impression is that the Linux kernel people aregenerally strongly opposed to what I could call 'code drops', whereforeign

My problem with the direction that modern NFS protocol developmentis going is, to put it succinctly, that everyone involved seems towant to turn NFS into AFS or another real networked filesystem . Instead of just improving NFS as itstands, they seem to want to change it into something substantiallydifferent, something that would require a major restructuring of allsorts of things in order to use.

So what do I consider 'NFS as it stands'? To me, the virtues of NFS arethat it is a fast,

One common proposed solution to the problem of simple HTML generation is a templating system. Apart from anypractical issues (all of which can be worked around), I've come torealize that I believe that they're the wrong answer in general, becausetemplating systems are solving a different problem.

At least for me, the problem simple HTML generation solves is thatHTML is annoyingly verbose and picky to write directly by hand (andpartly as a result is difficult to cleanly embed into Python code).This

Programs on our web server machine recently started complaining aboutbeing unable to set up semaphores (well, once we figured out what theerror message meant). This rapidly sent us on an expedition into theunderdocumented mists of the kernel.sem sysctl, and so I'll writedown what I've learned about what I think is going on.

In the grand style of System V IPC in general, what programs allocateis not semaphores, but semaphore arrays (officially called 'semaphoresets'). A semaphore

Here's something that I am surprised is not already in the Pythonstandard library: a simple module to generate and assemble HTMLfragments (or if you prefer, general XML fragments), up to and includingfull HTML pages.

I find it especially surprising because not only is this somethingthat a lot of people wind up needing to do sooner or later (considergenerating error pages from inside a simple CGI program), but there'seven a very common simple model for it that everyone seems to writetheir

I know, NFS has a lot of new security features in both the more or lessmythical NFS v4 and in NFS v3 with some hacks. The problem is that theyall give me the wrong sort of security (as far as I can tell); likeother real network filesystems, they're all focused on authenticatingthe users. What I want is good authentication of the hosts.

(The problem with user-based authentication is that it takes out allforms of setuid . This forces a really

Given both the need for certificate authorities and the practical weaknesses that they have, it would be niceif it was easy to drop a CA without causing massive havoc. The moststraightforward way to implement this is to allow SSL certificates to besigned by more than one authority, and to be considered valid if any ofauthorities is trusted.

The problem with this is economic. Each CA is going to have to chargeyou their own payment in order to sign your certificate, which meansthat most people will never buy this

I've been dancing around this issue recently, but it's time to comeout and say it explicitly: if you want things to actually be secure,you cannot ask users to manage their own security .

In practice, users are not interested in security (well, not much)and are not going to do it, and the rare ones that are interested anddo care almost certainly don't know enough to make sensible choices . What you get if you make users manage their ownsecurity is more