One solution (I’m sure there are others, maybe better ones) is to make the shell script create a temporary signature file and echo the path to that file, then execute the shell script using backticks.

Shell script (don’t forget to chmod 744):

#!/bin/bash                                                                                          

thesigfile=~/.mutt/rsig

echo  "Marianne Promberger PhD, King's College London
http://promberger.info" > $thesigfile
R --version | head -n 1 >> $thesigfile
cat /etc/issue | head -n 1 | cut -d " " -f 1-2 >> $thesigfile
echo $thesigfile

muttrc:

send-hook '~t r-help' 'set signature=`~/.mutt/signature_r-help`'

• Create a text file that contains all the recipients, one on each line. This can be the full e-mail address, or it can be the alias you have defined in your mutt aliases file (which is your mutt “addressbook”). For our example, we’ll call it recipients.txt
• Create a text file with the text of your message. Let’s call it message.txt.
• Create a bash shell script containing the following:

  #!/bin/bash
  while read line
  do
  mutt $line -s 'Message subject'  < message.txt
  done < recipients.txt

  Where "Message subject" is whatever your message subject should be. Of course, you need to run your shell script from the directory in which the files "message.txt" and "recipients.txt" are stored. Otherwise, you need to substitute their names with the full path name, e.g. ~/message.txt.

• Make your bash script executable and run it. Done. Your individual e-mails should show up in your mailfolder for sent mail (defined by set record=... in your ~/.muttrc.

ls *.!(Rnw|tex)

Run from a shell script, however, this would give the error:

line 5: syntax error near unexpected token `('

It turns out on ubuntu, the shell option extglob is set for an interactive shell, but not for the non-interactive shell that is used when you run a script. You can see whether “extglob” is on like this, either from a commandline or by putting the line into your script:

shopt extglob

If it’s off and you want it on, put into your script:

shopt -s extglob

An alternative (that you might not want, I’m not sure what else it might affect) is to change the opening line of your script to read

#!/bin/bash -i

This runs your script in an interactive shell and should thus have the same behavior as the commandline. Generally, a neat trick is to use the -x option to debug shell scripts:

#!/bin/bash -x

An alternative way to get files whose names match a certain pattern is of course to use find. Here, you can either use limited globbing patterns with the -name option, and combine several patterns using -o, like this:

find . -name "*.tex" -o -name "*.txt"

Find also has a -regex option. If you use that, you probably want to use -regex-type=posix-extended to get a behavior that is more similar to extended regular expressions that you might know, for example from sed. Additionally, you have to watch out that find needs the regular expression to match the entire filename including the directory. Here is an example for this:

audrey:~/tmp/testdir$ ls
blah.tex  blah.txt
audrey:~/tmp/testdir$ find . -regex "blah\.tex"
audrey:~/tmp/testdir$ find . -regex "\./blah\.tex"
./blah.tex

Here is an example for the difference between the default and the extended regex pattern behavior:

audrey:~/tmp/testdir$ find . -regex "\./blah\.(tex|txt)"

finds nothing, but:

audrey:~/tmp/testdir$ find . -regextype posix-extended -regex "\./blah\.(tex|txt)"
./blah.tex
./blah.txt

You could alternatively get the desired behavior with the default regex by escaping the grouping parentheses and the “|” operator:

audrey:~/tmp/testdir$ find . -regex "\./blah\.\(tex\|txt\)"
./blah.tex
./blah.txt

But that starts getting really hard to read.

{ rm "$file" && awk '!x[tolower($1)]++' > "$file"; } < "$file"

Case-sensitive:

{ rm "$file" && awk '!x[$1]++' > "$file"; } < "$file"

Here's a shell script you could use, as it stands, only works for one file at a time:

#!/bin/bash                                                                                  

usage()
{
cat << EOF                                                                                   

usage: $(basename $0) options filename                                                       

Removes duplicates from a file                                                               

OPTIONS:
   -h      Show this message
   -i      case insensitive
EOF
               }                                                                             

insensitive="no"                                                                             

while getopts "hi" option; do
    case $option in
        h)
            usage  ; exit 0
            ;;
        i)
            insensitive="yes"
            ;;
        "")
            usage ; exit 1
            ;;
        *)
            usage  ; exit 1
            ;;
    esac
done                                                                                         

shift $(($OPTIND - 1))                                                                       

filename="$1"                                                                                

if [ "$filename" == "" ] ; then
    usage ; exit 1
elif [ ! -f "$filename" ] ; then
    echo "File $filename does not exist" ; exit 1
fi                                                                                           

# make a backup
cp "$filename" "$filename"~                                                                  

if [ $insensitive == "yes" ] ; then
    { rm "$filename" && awk '!x[tolower($1)]++' > "$filename"; } < "$filename"
else
    { rm "$filename" && awk '!x[$1]++' > "$filename"; } < "$filename"
fi

Here's some nice concise information about getopts and shift.

I formatted this with gparted, first to ext3, then to ext2 (I wanted something that would preserve permissions), but after backup up some files to it (using rsync and rdiff-backup) I ended up with lots of input/output errors and bad superblocks and whatnot.

I then used gparted to make it ReiserFS, and that worked. One other thing that I did differently was that after formatting the SD card to ReiserFS, I removed the card, then shut down the machine and rebooted before reinserting the card and actually putting any data on it. I hadn’t done this for the ext* FS, no clue if it could have made a difference.

The filesystem works nicely and it seems quite a bit faster than both ext3 and ext2 (I have mostly small text files, and a few pdfs).

However, letting the card be automounted (by HAL, I assume?) resulted in occasional total freezes when mounting/ unmounting.

So I put a line into /etc/fstab

/dev/mmcblk0p1  /media/kate                 auto    auto,user,rw,exec 0 0

and now I can just leave the card in.

However, the laptop then failed to suspend and resume properly. That was solved by putting a script each into /etc/acpi/suspend.d and resume.d to unmount and remount the card:

audrey:~$ cat /etc/acpi/suspend.d/01-umount-kate.sh
#!/bin/sh

/bin/umount /media/kate

and …

audrey:~$ cat /etc/acpi/resume.d/91-mount-kate.sh
#!/bin/sh

/bin/mount /media/kate && /bin/chown mpromber:mpromber /media/kate

Nicola and I have been joking for some time that there should be a shell script to check whether the Pembury currently offers Augustiner. Well, it turns out this is easily possible, since the Pembury is in fact a Linux-powered pub whose website directly and accurately reflects what’s in the cellar. Enter lynx-dump and we’re all set:

#!/bin/bash
WEBSITE=http://www.individualpubs.co.uk/pembury/drinks.html
AUGUSTINER=$(/usr/bin/lynx -dump $WEBSITE | /bin/grep -i augustiner)
JEVER=$(/usr/bin/lynx -dump $WEBSITE | /bin/grep -i jever)
ANDECHS=$(/usr/bin/lynx -dump $WEBSITE | /bin/grep -i andechs)
if [ -n  "$AUGUSTINER" ]; then
         echo "The PT currently serve:
$AUGUSTINER
$JEVER
$ANDECHS"
elif    [ -n "$JEVER" -o  -n "$ANDECHS" ]; then
         echo "The PT currently serve no Augustiner, but they serve:
$JEVER
$ANDECHS"
else
     echo "Sorry, the PT currently serve neither Augustiner, nor Jever, nor Andechser."
fi

As you’ll notice, this also checks for Andechser or Jever as alternative solutions to our cravings for German beer. :)

For even more geeky fun, I’ve put up a mail reply service. If you send an e-mail with the subject line “PT-augustiner-info” to my private e-mail address (my first name (at) my last name (dot) info), you should receive a reply containing the up-to-date information.

This service uses procmail and anohter shell script.

The shell script:

#!/bin/bash
SENDER=$(formail -x "From:")
WEBSITE=http://www.individualpubs.co.uk/pembury/drinks.html
AUGUSTINER=$(/usr/bin/lynx -dump $WEBSITE | /bin/grep -i augustiner)
JEVER=$(/usr/bin/lynx -dump $WEBSITE | /bin/grep -i jever)
ANDECHS=$(/usr/bin/lynx -dump $WEBSITE | /bin/grep -i andechs)
if [ -n  "$AUGUSTINER" ]; then
      echo "The PT currently serve
$AUGUSTINER
$JEVER
$ANDECHS" | mail "$SENDER" -s "The PT serve Augustiner"
elif    [ -n "$JEVER" -o  -n "$ANDECHS" ]; then
      echo "The PT currently serve no Augustiner, but they serve:
$JEVER
$ANDECHS" | mail "$SENDER" -s "The PT currently serve no Augustiner, but ..."
else
      echo "Sorry, the PT serve neither Augustiner, nor Andechser, nor Jever
But you might check out $WEBSITE for other nice beers." | mail "$SENDER" -s "Sorry, no Augustiner, Jever, or Andechser beer at the PT"
fi

The recipe in ~/.procmailrc:

:0
* ^Subject.*PT-augustiner-info$
| /home/mpromber/bin/augustiner

Addendum

The e-mail information service now also works if you send an e-mail to augustiner (at) mylastname (dot) info. If you’re unsure what my last name is, look at the URL of this blog :) The modified procmail recipe for this (since one can never have too many examples of procmail recipes):

:0
* (^Subject.*PT-augustiner-info$)|(^To.*augustiner@promberger.info$)
| /home/mpromber/bin/augustiner

set sendmail_wait = -1

in my ~/.muttrc, but mutt doesn’t let me know if there are any error messages. That’s not good, and it would be ironic to gain a few seconds when hitting y in mutt just to nervously dig around in error logs all the time. In addition, while I like my new mail queue setup for the laptop,I find that, too, a bit too silent: the mail gets queued without any notification whenever I’m offline, and queued mail doesn’t get sent automatically when I’m back online (I actually prefer that — better that than inadvertently sending off mails that I was planning to delete from the queue).

So I wrote a shell script that checks both for errors and for queued mail and notifies me via the local exim4 MTA with messages that go into /var/mail/username. I’ve put that shell script online: checklog. This is all pretty basic stuff, but it might come in handy for someone, or if you’re new to shell scripting, you can never have too many examples.

I’ve put it into my ~/bin, made it executable, and call it every two hours and at reboot from ~/.crontab.

0 */2 * * *  /home/mpromber/bin/checklog
@reboot      /home/mpromber/bin/checklog

To make it take effect:

crontab ~/.crontab

On the laptop, I’ve also put a symbolic link to that script into /etc/acpi/resume.d so it gets executed on waking up from suspend, because that’s likely to have a correlation with wanting to be reminded of queued mail:

sudo ln -s /home/mpromber/bin/checklog /etc/acpi/resume.d/99-checklog.sh

Note that I had to give the symlink a name ending in “.sh”, since /etc/acpi/resume.sh above that directory only calls scripts with that pattern:

#!/bin/bash

# Source from /etc/acpi/resume.d/
for SCRIPT in /etc/acpi/resume.d/*.sh; do
    if [ -x $SCRIPT ]; then
        . $SCRIPT
    fi
done