rpatterson.mailsync 0.1

Requirements

• mswatch

• OfflineIMAP

• Gnus

Actually, they’re all kinda optional. The OfflineIMAP sync wrapper script can be used with mswatch without Gnus. The Gnus checkers can be used without OfflineIMAP. For that matter, the OfflineIMAP sync wrapper script can be used without mswatch, but why would you? :)

Installation

All you need is easy_install:

$ easy_install rpatterson.mailsync

If you have a /usr/local/emacs/site-lisp directory, the mailsync-gnus.el library will be installed there. To use the mailsync/gnus-check function, you’ll need to make sure it’s loaded in your emacs. You can do this by adding the following to your .gnus.el:

(load-library "mailsync-gnus")

To use mswatch, copy the example ~/.mswatchrc to your home directory and see the “MAILSYNC:” comments for what to change. Use “mailsync_gnus_watch –help” to see what options are available to modifying the watcher behavior:

# minimum time after first queued mailbox change to synchronization (default: 10s)
#base_delay 10

# minimum time between two syncs or failed attempts (default: 60s)
#inter_delay 60

# minimum time between two syncs or failed attempts for specific lists
#inter_delay 30 important_list
#inter_delay 600 high_volume_list another_list

# maximum waiting time between failed attempts (default: 600s)
#max_delay 600

# program (and arguments) to run to sync the mail stores (required)
# sync mswatch-sync

# MAILSYNC: use the following to have mswatch use your OfflineIMAP
# setup to sync folders on change.
sync mailsync_offlineimap

# prefix this string to sync's mailboxes; useful as mbsync channel (optional)
# the first string ("mydomain") is always prefixed
# the second string (":") is prefixed only when syncing a particular mailbox
mailbox_prefix foo :

# a store to watch, call it "local" (required)
store local
{
    # program (and args) that will monitor this store for changes (required)
    # see 'man watch_maildirs' to tell watch_maildirs where to find mail
    # watch watch_maildirs

        # MAILSYNC: use the following to have your local Gnus check
        # folders as they change, otherwise, just use the above.
    watch mailsync_gnus_watch
}

# the other store to watch, call it "mydomain" (required)
store foo.com
{
    # program (and args) that will monitor this store for changes (required).
    #
    # Uses ssh private/public keys to login without password prompting.
    # Uses ssh BatchMode so that 'mswatch' promptly detects disconnects.
    # Uses 'inputkill' to run 'watch_maildirs' so that 'watch_maildirs'
    # promptly exits if the connection dies.
        # watch ssh -o BatchMode=yes foo.com inputkill watch_maildirs

        # MAILSYNC: use the following to have your remote Gnus check
        # folders as they change, otherwise, just use the above.
    watch ssh -o BatchMode=yes foo.com inputkill mailsync_gnus_watch
}

TODO

• Use optparse for syncers

  Add built-in help and clearer option and argument handling for the syncers using optparse.

• Use delay in watchers/checkers

  Currently, the checkers run every time the watcher emits a folder name. Most maildir changes emit the same folder multiple times resulting in the checker running reduntantly. With mswatch, the logic for coalescing events using a delay is in the mswatch process. To address this problem, that logic would have to be extended to the watchers. This is another reason among many for reimplementing mswatch.

• Invoke OfflineIMAP in the same process

  Currently, mailsync invokes OfflineIMAP as a subprocess which is a little wasteful given how heavy launching a python app can be. I briefly looked at the OfflineIMAP code to see if it could be easily done but was disappointed.

  It would be great if any OfflineIMAP people want to show me how I can do this.

• Long running syncers

  Currently, mswatch invokes the sync process anew every time. Pretty much any sync process establishes one or more network connections. There’s no need to do this every time. Better to have a long running sync process that mswatch can feed the folders to sync as they require syncing. Implementing this would require modifying or reimplementing mswatch itself. It would also require support in the sync process. Perhaps OfflineIMAP could be used as a library to accomplish this.

• Ignore duplicate maildir notifications

  As described on the mswatch page, every sync is redundantly issued twice. To address this would require modifying or reimplementing mswatch itself.

• maildrop and gnus splitting?

  Maybe have maildrop directly invoke Gnus splitting and feed incomming messages to be split at time of delivery. This would eliminate redundant syncs on the INBOX where gnus would otherwise just immediately move the message into another folder. This approach is, however, probably way to heavy for a maildrop pipeline.

  An alternative approach would be to use a maildir (~/Incomming) separate from the real INBOX maildir (~/Maildir) where mails would first be delivered. This incomming maildir could be monitored using a checker/watcher whose only real purpose is to get gnus to check the incomming maildir and split messages. The split would then move the message to the destination or fallback to the real INBOX maildir which would in turn trigger any real watchers/checkers used by mswatch.

  This approach requires no additional mailsync support. It also keeps maildrop job small and light, decoupling the gnus splitting work from delivery.

  An advantage of either approach is that mail would be split on the server even when the local mswatch wasn’t connected. As it is now, mail is only split when mswatch is running or if the Gnus running on the server checks all mail periodically.

• Use Gamin

  Use Gamin to provide compatibility across the file modification services available.

Changelog