Download
Source
- Current release: 1.2.0
- Other releases
- Development (in subversion): https://svn.code.sf.net/p/mswatch/code/trunk/ (Browse)
Packages
- Debian: mswatch and watch-maildirs
a utility to watch mailstores for changes and initiate mailbox syncs
mswatch is a command-line Linux utility that efficiently directs mail synchronization between a pair of mailboxes.
mswatch watches mailboxes for changes to know when to initiate mailbox syncs. Using mswatch, your mail synchronization program can be invoked on demand rather than through periodic polls, allowing it to deliver mail more promptly and with lower network and server overheads.
mswatch is designed to work in conjunction with your mailbox synchronization program; e.g., mbsync or OfflineIMAP. mswatch monitors mailstores for changes by running itself on both the client and server (shell access to each is required) and currently supports watching Linux-hosted Maildirs, including Maildir++ folders.
mswatch is released under the terms of version 2 of the GNU General Public License.
Keeping a set of mailboxes on multiple computers means keeping the copies synchronized (eg on one's desktop and laptop or on a personal computer that cannot be reached while on the road and an always-reachable server). While the IMAP protocol is designed to support this and is widely used, IMAP clients can only detect mailbox changes by querying the server. Thus clients generally either sync when the user requests or sync periodically. However, because each mailbox sync uses server and network resources and because users often have a number of mailboxes, many of which receive mail infrequently, one must compromise between prompt message delivery and low server and network resource usage. Typical practice is to sync only when the user requests or to sync periodically with 5-10 minute frequencies. Nonetheless, it is often helpful for users to see new mail fairly soon after its arrival (eg notifications, group meeting changes, or active conversation threads).
mswatch addresses this speed of delivery vs resource usage trade-off using interrupt-based instead of polling behavior to detect mailbox changes. mswatch asks each of the two mailstores to send mailbox change notifications; when mswatch receives a notification it in turn invokes the user's mailbox synchronization program for the changed mailbox. Thus, idle mailboxes do not use active resources and prompt mailbox synchronization is efficient.
While the above explains why one might want interrupt- instead of polling-based mailbox syncing, why use mswatch instead of another interrupt-based approach? Other known approaches and their limitations:
If mail is delivered only to a single folder on the remote host and all other mailbox changes occur only locally then a client and server that support the IDLE command are sufficient to use interrupt-based synchronization.
mswatch watches two sets of mailboxes for changes; when a change is detected mswatch invokes the user's mail synchronizer for the changed mailbox(es).
Each set of mailboxes (a "mailstore" in mswatch terminology) is watched through an external program which watches for changes to its mailstore and prints the name of a mailbox when the box is changed. Through this interface mswatch can watch local or remote (using ssh) mailstores. mswatch currently includes the program watch_maildirs to watch Linux hosted Maildirs. Programs to watch other mailstore types or support more platforms are most welcome! (If you are open to helping to test watch_mboxes, please email the mswatch list.)
mswatch reads and coalesces the mailbox names from each of the two mailstores. Following a short delay after a mailbox change (to allow multiple mailboxes to be synced with the same synchronization connection) mswatch invokes the mailbox synchronization program with the names of the changed mailboxes. mswatch was developed with mbsync in mind, but any mail synchronizer that implements the mailbox synchronizer interface can be invoked.
mswatch is designed to robustly interact with other programs and with networks:
watch_maildirs watches a Maildir-based mailstore for and reports changes; Maildir and Maildir folders (Maildir++) are supported. watch_maildirs uses Linux's inotify (2.6.13+) or dnotify (2.4.19+) interfaces to watch the Maildirs for mailbox changes.
inputkill is a small program that promptly kills a remote mailstore watcher when its connection to mswatch's dies; without it remote mailstore watchers would only exit much later, running needlessly. inputkill monitors its standard input; when stdin is closed, inputkill kills its child process and exits.
socketwatch monitors mail synchronization programs to detect and recover from program freezes while synchronizing – for example, we have seen deadlocks in interactions with SSL libraries and while IMAP clients wait for handshakes. Without socketwatch, such deadlocks can hang the mail synchronization program indefinitely. With socketwatch, they are reduced to increasing the run-time of the synchronization.
Because mswatch abstracts mail changes and synchronization to the mailbox (instead of message) level and because mail watcher communication is one-way, extra mailbox syncs occur. While it would be great to avoid this extra work, it is in the noise compared to the number of empty syncs that polling accumulates.
For example, the case of new mail delivered to the mail server's INBOX:
Thus two syncs occur in this case instead of the single necessary sync.