Wandering Thoughts archives

A (D)VCS feature that I'd really like

Here's something that I want: I want a version control system (ideally a distributed one) that can preserve file timestamps. I'm looking for such a weird feature because I happen to have created something that I want to put under version control where (some of the) file timestamps are significant and need to be preserved.

(This is yet another hazard of using files as entries, albeit in a slightly different form.)

This is an uncommon feature in version control systems at the best of times, partly because actually doing this can muck up source builds when you revert to older versions of files (with older timestamps). I know that neither Mercurial nor Git have this, and while I haven't looked into the 'secondary' DVCSes (such as bzr) very much, my impression is that none of them do it either.

(File timestamps don't have to be first class version controlled data; I'd be happy if the file timestamp was only recorded when some other change to the file was committed, as opposed to causing commits every time it was the only thing that changed.)

I suspect that most practical workaround is a program to save and restore the file timestamps for a directory hierarchy, and then making the file of timestamp data (and possibly the program) part of what's under version control. This requires an extra step on checkouts and especially commits, and if I ever do much branching I'll probably get merge conflicts all the time on the file of timestamp data, but at least it preserves the data.

A small drawback to Wietse Venema's TCP Wrappers

Wietse Venema's tcpwrappers is mostly used for controlling access to services run from inetd or your local equivalent, where you are not expecting high performance or high load. However, it can be built as a library that you link your daemon against, and some daemons are.

(At least on Linux, both OpenSSH and the portmapper are built this way.)

It turns out that there is a small drawback to using tcpwrappers this way in some sorts of high-performance applications, specifically in application where you expect a lot of connections or want to be able to dispatch connections very fast. The drawback is this:

Tcpwrappers does no caching of the hosts.allow and hosts.deny files.

Every time you call the tcpwrappers routines to check for host access, they open, read, and parse the files completely from scratch. If your files are small, this doesn't matter, but if they're large, you may be burning more CPU time on this than you expect.

(You're very unlikely to be hit with disk IO for reading the files; if you're getting any sort of connection volume they'll be in the filesystem cache.)

One useful thing to know for best performance is that tcpwrappers deals with the files strictly a line at a time (instead of parsing the entire file, then evaluating the parsed rules). This implies that it's worth putting the rules for the most common cases first if you have big files.

(Big hosts.allow and hosts.deny are probably uncommon, but I once had a hosts.deny file that was over 4,000 lines long. That was admittedly a special case, and eventually got replaced with better technology.)