For reasons beyond the scope of this entry, we've recently wantedto let certain people read some shared mailboxes through our IMAPserver instead of other mechanisms such as 'mail to HTML' and an access restricted Apache setup . Inour configuration, there are broadly three approaches we could taketo do this, two of which actually work. The obvious but non-workingapproach is to tell people to use the absolute path to the mailbox;this doesn't work because Dovecot index files get in the way .

I was adding DMARC DNS records to some ofour domains today, and the process of doing this made me realizesomething about how modern protocols that use the DNS structuretheir interactions with it. Famously, the way you add arbitraryinformation to DNS is with DNS TXT records , which take basicallyarbitrary text. However, there are two approaches to where thisinformation goes, the old approach and the new one.

In the old approach, your DNS TXT record or records go directlyon the domain or subdomain they're

I recently read Evan Ovadia's Data Races in Python, Despite theGlobal Interpreter Lock ( via ),which discusses what its title says. Famously, the Global InterpreterLock only covers the execution of individual Python bytecodes (moreor less) , and what this does and doesn'tcover is tricky, subtle, and depends on the implementation detailsof Python code . For example, making a Pythonclass better and more complete can reduce what's safe to do withit without explicit locking.

These days,

It's common for sophisticated Unix init systems to also be some degreeof service management systems; the most obvious example is Linux'ssystemd. However, many people have observed that it doesn't haveto be this way and have created separate systems for this, such as D. J. Bernstein's daemontools .Since service management (or lack of it) has become one of theimportant areas of Unix init systems , youmight wonder why they've come to have this responsibility. A significant

A while back I said something on Twitter :

Thesis: pretty much anything can boot a Unix system in a staticconfiguration. The important things about an init system are all ofthe aspects of what happens after booting and outside of a singleboot.

In the very beginning, booting a Unix system was considered avery simple thing ; the V7 /etc/rc is remarkablyshort. After a while various complexities showed up and because theproblem wasn't well understood, people created various complicatedsystems for dealing with

We have a serial console server that we have connected to all of our important servers, and we haveour servers set up so that the serial console is one of the placesthat Linux kernel messages go when they're printed to the 'console' . Since we log all of the console output, wewant all kernel messages to reliably go to the (serial) console.Recently we discovered that our Ubuntu servers were not doing this.Instead, Ubuntu limits the console to log level '4' and higher

The Linux kernel has an internal system to assign (or let peopleassign) a log level for all kernel messages, ranging from 'debug'at the bottom up through 'emerg' at the top. You can read about itin syslog(2) ,and these kernel log levels become syslog(3) log levels,can be reported (and thus manually filtered) by dmesg(1) and so on.Given this, you might wonder if it's useful to do anything differentfor different log

A web server that serves a directory tree of static files seems like asimple thing (if you ignore TLS and the inherent complexity in HTTP),definitely simpler than a dynamic system and often something you couldwhip up in short order given a HTTP handling library. In practice thereare a number of additional complexities in handling static directorytrees that will rapidly complicate your simple little server.

The essentially mandatory complexity is setting a good Content-Type so that browsers are willing to interpret your HTML and CSS as HTMLand CSS

We had a learning experience theother day. Part of the learning experience was about the behaviorof du in the face of hardlinks andanother part of it was to do with odd ZFS space usage behavior, but thelargest part and the ultimate cause was because ' rsync -a ' doesn'tpreserve hardlinks . If you copy or move a directory tree with ' rsync-a ' and it contains internal hardlinks, your new copy will break thosehardlinks and copy each hardlink separately. Among other effects, thiswill